/// <summary>
/// Sets the named sets database tables 1 general.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="table">The table.</param>
private static void setNAMED_SETS_DATABASE_TABLES_1_GENERAL(Model model, List <Dictionary <string, string> > table)
{
foreach (Dictionary <string, string> tableRow in table)
{
TableSet tableSet = model.OutputSettings.FillItem(tableRow["DBNamedSet"]);
tableSet.SortOrder = tableRow["SortOrder"];
tableSet.IsUnformatted = Adaptor.fromYesNo(tableRow["Unformatted"]);
tableSet.ModeStart = Adaptor.toInteger(tableRow["ModeStart"]);
string modeEnd = tableRow["ModeEnd"];
if (modeEnd.ToUpper() == "ALL")
{
tableSet.AllModesUsed = true;
}
else
{
tableSet.AllModesUsed = false;
tableSet.ModeEnd = Adaptor.toInteger(modeEnd);
}
tableSet.BaseReactionXCoordinate = Adaptor.toDouble(tableRow["BaseReacX"]);
tableSet.BaseReactionYCoordinate = Adaptor.toDouble(tableRow["BaseReacY"]);
tableSet.BaseReactionZCoordinate = Adaptor.toDouble(tableRow["BaseReacZ"]);
tableSet.ModalHistoryOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["ModalHist"]);
tableSet.DirectIntegrationHistoryOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["DirectHist"]);
tableSet.NonlinearStaticOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["NLStatic"]);
tableSet.MultiStepStaticOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["Multistep"]);
tableSet.LoadCombinationOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eLoadCombinationOutput>(tableRow["Combo"]);
tableSet.SteadyStateOutput = tableRow["Steady"];
tableSet.SteadyStateOutputOption = tableRow["SteadyOpt"];
tableSet.PowerSpectralDensityOption = tableRow["PSD"];
}
}
public static TableSet <T> GetTable <T>(string file) where T : TableBase, new()
{
var tp = typeof(T);
TableSet <T> t = null;
object tab;
if (sTables.TryGetValue(tp, out tab))
{
t = tab as TableSet <T>;
}
if (t == null)
{
t = new TableSet <T>();
sTables[tp] = t;
}
if (!t.ContainsTable(file))
{
var f = string.Format(fileFormat, file);
var txt = AssetDatabase.LoadAssetAtPath <TextAsset>(f);
if (txt != null)
{
var merge = TableSet <T> .LoadAsNew(file, txt.text);
TableSet <T> .MergeTo(merge, t);
}
}
return(t);
}
public DbSyncProvider(TableSet tableSet)
{
this.tableSet = tableSet;
sourceDb = new QueryRunner(tableSet.SourceConnectionStringName);
destinationDB = new QueryRunner(tableSet.DestinationConnectionStringName);
syncChangesData = new SyncChangesData(tableSet);
}
public void QueryWithContainsAndComplexFunction()
{
// Arrange
var names = new List <string>
{
Germany,
Finland
};
TableSet <Country> tableSet = GetTableSet();
Expression <Func <Country, bool> > hasName = x => names.Contains(x.Name);
Expression <Func <Country, bool> > exists = x => x.IsExists && x.Population > 1000000;
var filter = hasName.And(exists);
// Act
List <Country> result = tableSet.Where(filter).ToList();
// Assert
Assert.NotNull(result);
Assert.Equal(2, result.Count);
List <string> resultNames = result.Select(p => p.Name).ToList();
Assert.Contains(Germany, resultNames);
Assert.Contains(Finland, resultNames);
}
public SyncStatusReport(TableSet tableSet)
{
this.tableSet = tableSet;
sourceDB = new QueryRunner(tableSet.SourceConnectionStringName);
destinationDB = new QueryRunner(tableSet.DestinationConnectionStringName);
restClient = new RestClient(BaseUrl);
}
public async Task UseQueryExpressionTwice()
{
// Arrange
const int value = 1800;
TableSet <Country> tableSet = GetTableSet();
// Act
IQueryable <Country> queryTwoEntity =
tableSet.Where(
p => p.Formed > new DateTime(value, 1, 1) &&
(p.PresidentsCount < 10 ||
p.Population < 10000000 && p.PresidentsCount > 10 && p.IsExists));
IQueryable <Country> queryOneEntity = tableSet.Where(p => p.Name == Germany);
Country result = await queryOneEntity.SingleAsync();
List <Country> results = await queryTwoEntity.ToListAsync();
// Assert
Assert.NotNull(result);
Assert.Equal(Germany, result.Name);
Assert.Equal(2, results.Count);
Assert.Contains(Finland, results.Select(p => p.Name));
Assert.Contains(Spain, results.Select(p => p.Name));
}
/// <summary>
/// Sets the named sets database tables 2 selections.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="table">The table.</param>
private static void setNAMED_SETS_DATABASE_TABLES_2_SELECTIONS(Model model, List <Dictionary <string, string> > table)
{
foreach (Dictionary <string, string> tableRow in table)
{
TableSet tableSet = model.OutputSettings.FillItem(tableRow["DBNamedSet"]);
switch (tableRow["SelectType"])
{
case "Table":
tableSet.TableNames.Add(tableRow["Selection"]);
break;
case "LoadPattern":
LoadPattern loadPattern = model.Loading.Patterns.FillItem(tableRow["Selection"]);
tableSet.LoadPatterns.Add(loadPattern);
break;
case "LoadCase":
LoadCase loadCase = model.Loading.Cases.FillItem(tableRow["Selection"]);
tableSet.LoadCases.Add(loadCase);
break;
case "Combo":
LoadCombination loadCombo = model.Loading.Combinations.FillItem(tableRow["Selection"]);
tableSet.LoadCombinations.Add(loadCombo);
break;
}
}
}
public async Task AddOrUpdateEntitiesWithNullParameterAsync()
{
// Arrange
Mock <ITableRequestExecutor <Country> > mock = MocksFactory.GetQueryExecutorMock <Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet <Country>(tableClient)
{
RequestExecutor = mock.Object
};
IEnumerable <Country> result = null;
// Act
try
{
result = await context.AddOrUpdateAsync((IEnumerable <Country>) null, CancellationToken.None);
}
catch (ArgumentNullException)
{
}
// Assert
Assert.Null(result);
mock.Verify(executor => executor.ExecuteBatches(It.IsAny <IEnumerable <Country> >(), It.IsAny <Func <ITableEntity, TableOperation> >()), Times.Never());
}
public override string ToString()
{
var tableCount = TableSet.Count;
var totalRowCount = TableSet.Sum(table => table.Rows.Count);
return($"{Database} ; Total row count = {totalRowCount} ; Table count = {tableCount}");
}
public TableLoader(int id, string file, bool merge, TableSet <T> table, string folder, string extension)
{
mFile = file;
mMerge = merge;
mTable = table == null ? TableSet <T> .Instance : table;
Identify = id;// TableSet<T>.HashTable(file);
AssetPath = StringUtil.Concat(folder, file, extension);
mTable.WaitForLoading();
}
/// <summary>
/// 通用的分页方法(多条件)
/// </summary>
/// <param name="ts">TableSet</param>
/// <param name="rpt">Repeater带分页控件</param>
/// <typeparam name="TEntity">实体类</typeparam>
public static List <TEntity> ToList <TEntity>(this TableSet <TEntity> ts, Repeater rpt) where TEntity : class, Core.Infrastructure.IEntity, new()
{
int recordCount;
var lst = ts.ToList(rpt.PageSize, rpt.PageIndex, out recordCount);
rpt.PageCount = recordCount;
return(lst);
}
public ContainsTests()
{
TableSet <Country> tableSet = GetTableSet();
tableSet.Add(
new Country
{
Area = 357021,
Continent = "Europe",
TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc },
Formed = new DateTime(1871, 1, 18),
Id = Guid.NewGuid(),
IsExists = true,
Name = Germany,
Population = 81799600,
PresidentsCount = 11
});
tableSet.Add(
new Country
{
Area = 505992,
Continent = "Europe",
TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc },
Formed = new DateTime(1812, 1, 1),
Id = Guid.NewGuid(),
IsExists = false,
Name = Spain,
Population = 47190493,
PresidentsCount = 8
});
tableSet.Add(
new Country
{
Area = 674843,
Continent = "Europe",
TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc },
Formed = new DateTime(1792, 1, 1),
Id = Guid.NewGuid(),
IsExists = true,
Name = France,
Population = 65350000,
PresidentsCount = 24
});
tableSet.Add(
new Country
{
Area = 338424,
Continent = "Europe",
TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc },
Formed = new DateTime(1809, 3, 29),
Id = Guid.NewGuid(),
IsExists = true,
Name = Finland,
Population = 5421827,
PresidentsCount = 12
});
}
public void CreateTableSetWithNullTableClientParameter()
{
TableSet <Country> context = null;
// Act && Assert
Assert.Throws <ArgumentNullException>(() => { context = new TableSet <Country>(null); });
Assert.Null(context);
}
public void CreateTableSetWithNullTableClientParameter()
{
TableSet<Country> context = null;
// Act && Assert
Assert.Throws<ArgumentNullException>(() => { context = new TableSet<Country>(null); });
Assert.Null(context);
}
public void CreateTableSetWithNullTableNameParameter()
{
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
TableSet <Country> context = null;
// Act && Assert
Assert.Throws <ArgumentNullException>(() => { context = new TableSet <Country>(tableClient, null); });
Assert.Null(context);
}
/// <summary>
/// 事务
/// </summary>
/// <param name="database">数据库执行</param>
/// <param name="tableName">表名称</param>
public TableContext(DbExecutor database, string tableName = null) : base(database, tableName)
{
if (string.IsNullOrWhiteSpace(tableName))
{
Name = TableMapCache.GetMap <TEntity>().ClassInfo.Name;
}
TableSet = new TableSet <TEntity>(this);
IsMergeCommand = true;
Query = DbFactory.CreateQueryTable(this);
}
public bool IsTableLoaded <T>(string file) where T : TableBase, new()
{
int id = TableSet <T> .HashTable(file);
if (mTaskQueue.Contains(id) || TableSet <T> .Instance.ContainsTable(id))
{
return(true);
}
return(false);
}
public void CreateTableSetWithNullTableNameParameter()
{
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
TableSet<Country> context = null;
// Act && Assert
Assert.Throws<ArgumentNullException>(() => { context = new TableSet<Country>(tableClient, null); });
Assert.Null(context);
}
public DmmGameRankingTableClient(CloudStorageAccount storageAccount, string tableName)
{
this.storageAccount = storageAccount;
this.tableName = tableName;
var tableClient = storageAccount.CreateCloudTableClient();
table = new TableSet <DmmGameRankingEntity>(tableClient, tableName);
table.CreateIfNotExists();
}
public void SingleWithoutResult()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
Country result = null;
// Act
Assert.Throws <InvalidOperationException>(() => { result = tableSet.Single(p => p.Name == string.Empty); });
Assert.Null(result);
}
public async Task SingleOrDefaultAsyncWithPredicateWithoutResult()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country entity = await tableSet.SingleOrDefaultAsync(p => p.Name == "none");
// Assert
Assert.Null(entity);
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataRepository{TEntity, TPartitionKey, TRowKey}" /> class.
/// </summary>
/// <param name="cloudStorageAccount">The cloud storage account.</param>
public MetadataRepository(IStorageAccountWrapper storageAccountWrapper)
{
Args.IsNotNull(() => storageAccountWrapper);
cloudTableClient = storageAccountWrapper.CreateCloudTableClient();
cloudTableClient.DefaultRequestOptions.RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(45), 5);
var cloudTableName = typeof(TEntity).Name.Replace("Entity", String.Empty);
tableSet = new TableSet <TEntity>(cloudTableClient, cloudTableName);
}
public void FirstOrDefaultWithoutResult()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country result = tableSet.FirstOrDefault(p => p.Name == string.Empty);
// Assert
Assert.Null(result);
}
public async Task UseFieldInQueryExpression()
{
// Arrange
TableSet <LogEntry> tableSet = GetTableSet();
string message = string.Format(MessageTemplate, 2);
// Act
LogEntry result = await tableSet.FirstAsync(p => p.Message == message);
// Assert
Assert.Equal(result.Message, message);
}
private static Tuple <List <T1>, List <T2> > BuildResult(TableSet result)
{
if (result.Count != 2)
{
throw new DataException($"Expected 2 tables but received {result.Count} tables");
}
return(Tuple.Create(
result[0].ToObjects <T1>().ToList(),
result[1].ToObjects <T2>().ToList()
));
}
public void SingleWithExpressionWithOneResult()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country result = tableSet.Single(p => p.Name == France);
// Assert
Assert.NotNull(result);
Assert.Equal(France, result.Name);
}
public void Single()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
Country result = null;
// Act
Assert.Throws <InvalidOperationException>(() => result = tableSet.Single());
// Assert
Assert.Null(result);
}
public void SingleAfterWhereWithExpression()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country result = tableSet.Where(p => p.Population > 20000000).Single(p => p.Population < 30000000);
// Assert
Assert.NotNull(result);
Assert.Equal(Yugoslavia, result.Name);
}
public void SingleAfterWhereWithMultipleResult()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
Country result = null;
// Act
Assert.Throws <InvalidOperationException>(() => result = tableSet.Where(p => p.Population > 20000000).Single());
// Assert
Assert.Null(result);
}
public void SingleAfterWhere()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country result = tableSet.Where(p => p.Population > 60000000).Single();
// Assert
Assert.NotNull(result);
Assert.Equal(France, result.Name);
}
public void FirstWithExpressionWithMultipleResults()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
// Act
Country result = tableSet.First(p => p.Continent == Europe);
// Assert
Assert.NotNull(result);
Assert.Equal(Finland, result.Name);
}
public void CreateTableSetWithTableClientAndNameParameters()
{
// Arrange
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
const string tableName = "tableName";
// Act
var context = new TableSet<Country>(tableClient, tableName);
// Assert
Assert.Equal(tableName, context.RequestExecutorFactory.CloudTable.Name);
}
public void SingleWithExpressionWithMultipleResults()
{
// Arrange
TableSet <Country> tableSet = GetTableSet();
Country result = null;
// Act
Assert.Throws <InvalidOperationException>(() => result = tableSet.Single(p => p.Continent == Europe));
// Assert
Assert.Null(result);
}
public void CreateTableSetWithTableClientParameter()
{
// Arrange
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
// Act
var context = new TableSet<Country>(tableClient);
// Assert
Assert.Equal(typeof (Country).Name, context.RequestExecutorFactory.CloudTable.Name);
Assert.Equal(ExecutionMode.Sequential, context.ExecutionMode);
Assert.IsType<TableRequestSequentialExecutor<Country>>(context.RequestExecutor);
}
public void RemoveEmptyCollection()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
var countries = new List<Country>();
// Act
context.Remove(countries);
}
public void SetTheSameExecutionMode()
{
// Arrange
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient);
var executor = context.RequestExecutor;
// Act
context.ExecutionMode = ExecutionMode.Sequential;
// Assert
Assert.Equal(ExecutionMode.Sequential, context.ExecutionMode);
Assert.IsType<TableRequestSequentialExecutor<Country>>(context.RequestExecutor);
Assert.Same(executor, context.RequestExecutor);
}
public void RemoveEntitiesWithNullParameter()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
// Act
Assert.Throws<ArgumentNullException>(() => context.Remove((IList<Country>) null));
// Assert
mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IList<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never());
}
public async Task RemoveEntitiesAsync()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
IList<Country> countries = ObjectsFactory.GetCountries();
// Act
await context.RemoveAsync(countries);
// Assert
mock.Verify(executor => executor.ExecuteBatchesWithoutResultAsync(countries, TableOperation.Delete, It.IsAny<CancellationToken>()));
}
public void RemoveEntities()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
IList<Country> countries = ObjectsFactory.GetCountries();
// Act
context.Remove(countries);
// Assert
mock.Verify(executor => executor.ExecuteBatchesWithoutResult(countries, TableOperation.Delete), Times.Once());
}
public void AddOrMergeEmptyCollection()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
var countries = new List<Country>();
// Act
var result = context.AddOrMerge(countries);
// Assert
Assert.NotNull(result);
Assert.Equal(countries, result);
}
public void AddOrMergeEntitiesWithNullParameter()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
IEnumerable<Country> result = null;
// Act
Assert.Throws<ArgumentNullException>(() => { result = context.AddOrMerge((IEnumerable<Country>)null); });
// Assert
Assert.Null(result);
mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IEnumerable<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never());
}
public void AddOrMergeEntities()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
var countries = ObjectsFactory.GetCountries();
// Act
var result = context.AddOrMerge(countries);
// Assert
Assert.NotNull(result);
mock.Verify(executor => executor.ExecuteBatches(countries, TableOperation.InsertOrMerge), Times.Once());
Assert.Equal(countries, result);
}
public async Task AddOrMergeEntityAsync()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
Country country = ObjectsFactory.GetCountry();
// Act
Country result = await context.AddOrMergeAsync(country);
// Assert
Assert.NotNull(result);
mock.Verify(executor => executor.ExecuteAsync(country, TableOperation.InsertOrMerge, It.IsAny<CancellationToken>()));
Assert.Equal(country, result);
}
public void AddEntity()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
Country country = ObjectsFactory.GetCountry();
// Act
Country result = context.Add(country);
// Assert
Assert.NotNull(result);
mock.Verify(executor => executor.Execute(country, TableOperation.Insert), Times.Once());
Assert.Equal(country, result);
}
public void AddEntity_FluentMapping()
{
// Arrange
Mock<ITableRequestExecutor<Address>> mock = MocksFactory.GetQueryExecutorMock<Address>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Address>(tableClient)
{
RequestExecutor = mock.Object
};
Address model = ObjectsFactory.GetAddress();
// Act
Address result = context.Add(model);
// Assert
Assert.NotNull(result);
mock.Verify(executor => executor.Execute(model, TableOperation.Insert), Times.Once());
Assert.Equal(model, result);
}
static void TestTableInstance(int count = 1000000)
{
var table = new Table();
var type = typeof(TableSet<UserVO>);
SpeedTest.ConsoleTime("手动创建", count, () =>
{
var User = new TableSet<UserVO>(table, "User");
//table.Dispose();
});
SpeedTest.ConsoleTime("表达式树创建", count, () =>
{
var po = (TableSet<UserVO>)CacheManger.CreateInstance(type, table, "User");
//table.Dispose();
//Expressions.CreateInstance(type);
});
SpeedTest.ConsoleTime("反射创建", count, () =>
{
var po = (TableSet<UserVO>)Activator.CreateInstance(type, table, "User");
//table.Dispose();
});
}
public async Task RemoveEntityWithNullParameterAsync()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
// Act
try
{
await context.RemoveAsync((Country) null, CancellationToken.None);
}
catch (ArgumentNullException)
{
}
// Assert
mock.Verify(executor => executor.Execute(It.IsAny<Country>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never());
}
public async Task AddOrMergeEntitiesWithNullParameterAsync()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
IEnumerable<Country> result = null;
// Act
try
{
result = await context.AddOrMergeAsync((IEnumerable<Country>)null, CancellationToken.None);
}
catch (ArgumentNullException)
{
}
// Assert
Assert.Null(result);
mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IEnumerable<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never());
}
public async Task UpdateEntitiesAsync()
{
// Arrange
Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>();
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient)
{
RequestExecutor = mock.Object
};
var countries = ObjectsFactory.GetCountries();
// Act
var result = await context.UpdateAsync(countries);
// Assert
Assert.NotNull(result);
mock.Verify(executor => executor.ExecuteBatchesAsync(countries, TableOperation.Replace, It.IsAny<CancellationToken>()));
Assert.Equal(countries, result);
}
public void ChangeTableSetExecutionMode()
{
// Arrange
CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient();
var context = new TableSet<Country>(tableClient);
// Act
context.ExecutionMode = ExecutionMode.Parallel;
// Assert
Assert.Equal(ExecutionMode.Parallel, context.ExecutionMode);
Assert.IsType<TableRequestParallelExecutor<Country>>(context.RequestExecutor);
}
