public void ListAtomConstructorTest()
{
var atom = new ListAtom();
atom.Should().NotBeNull();
atom.Type.Should().Be(AtomType.List);
}
private static void InitDatabaseLoaders(DictionaryAtom initAtom)
{
var loaderArgs = new ListAtom();
{
var loaderDbo = new DictionaryAtom();
loaderDbo.Set("Catalog", "Realm");
loaderDbo.Set("Schema", "dbo");
loaderDbo.Set("Prefix", "game");
loaderArgs.Add(loaderDbo);
}
{
var loaderLive = new DictionaryAtom();
loaderLive.Set("Catalog", "Realm");
loaderLive.Set("Schema", "live");
loaderLive.Set("Prefix", "game");
loaderArgs.Add(loaderLive);
}
{
var loaderRef = new DictionaryAtom();
loaderRef.Set("Catalog", "Realm");
loaderRef.Set("Schema", "ref");
loaderRef.Set("Prefix", "cp");
loaderArgs.Add(loaderRef);
}
{
var loaderAdmin = new DictionaryAtom();
loaderAdmin.Set("Catalog", "Realm");
loaderAdmin.Set("Schema", "admin");
loaderAdmin.Set("Prefix", "cp");
loaderArgs.Add(loaderAdmin);
}
initAtom.Set("Loaders", loaderArgs);
}
/// <summary>
///
/// </summary>
/// <param name="commandResults"></param>
/// <param name="subListName"></param>
private void AddToSubList(IEnumerable <Atom> commandResults, string subListName)
{
var itResult = commandResults.GetEnumerator();
while (itResult.MoveNext())
{
var result = itResult.Current.CastAs <DictionaryAtom>();
var def = Repository.GetSubtype(SystemType.GetValue(), result.GetInt(IdColumn).ToString(CultureInfo.InvariantCulture));
if (def.IsNull())
{
throw new ObjectNotFoundException(string.Format(Resources.ERR_PRIMITIVE_NOT_FOUND, result.GetInt(IdColumn)));
}
var newsubList = false;
var subList = def.Def.GetAtom <ListAtom>(subListName);
if (subList.IsNull())
{
subList = new ListAtom();
newsubList = true;
}
subList.Add(result);
if (newsubList)
{
def.Def.Set(subListName, subList);
}
}
}
public void ListAtomGetBoolTest()
{
var listAtom = new ListAtom {
false, true, false
};
listAtom.GetBool(1).Should().BeTrue();
}
public void ListAtomGetRealTest()
{
var listAtom = new ListAtom {
12.5f, 25.0f, 37.5f
};
listAtom.GetReal(1).Should().Be(25.0f);
}
public void ListAtomGetBoolInvalidTest()
{
var listAtom = new ListAtom {
false, "test", false
};
listAtom.GetBool(1).Should().BeFalse();
}
public void ListAtomGetRealInvalidTest()
{
var listAtom = new ListAtom {
12.5f, "test", 37.5f
};
listAtom.GetReal(1).Should().Be(0.0f);
}
public void ListAtomGetIntInvalidTest()
{
var listAtom = new ListAtom {
15, "test", 35
};
listAtom.GetInt(1).Should().Be(0);
}
public void ListAtomCountTest()
{
var atom = new ListAtom {
15, 25
};
atom.Count.Should().Be(2);
}
public void ListAtomSetLongTest()
{
const long value = 2500;
var listAtom = new ListAtom {
value
};
listAtom.GetInt(0).Should().Be((int)value);
}
public void ListAtomGetIntTest()
{
var listAtom = new ListAtom {
15, 25, 35
};
listAtom.Count.Should().Be(3);
listAtom.GetInt(1).Should().Be(25);
}
public void ListAtomGetStringInvalidTest()
{
var listAtom = new ListAtom {
"test1", 25, "test3"
};
listAtom.Count.Should().Be(3);
string.IsNullOrEmpty(listAtom.GetString(1)).Should().BeTrue();
}
public void ListAtomGetStringTest()
{
var listAtom = new ListAtom {
"test1", "test2", "test3"
};
listAtom.Count.Should().Be(3);
listAtom.GetString(1).Should().Be("test2");
}
public void ListAtomSetDoubleTest()
{
const double value = 250.52D;
var listAtom = new ListAtom {
value
};
listAtom.GetReal(0).Should().Be(value);
}
public void ListAtomDumpNullParameterTest()
{
var atom = new ListAtom();
const string prefix = "Test";
Action act = () => atom.Dump(null, prefix);
act.Should().Throw <ArgumentNullException>();
}
public void ListAtomGetObjectInvalidTest()
{
var obj1 = new object();
var obj2 = new object();
var listAtom = new ListAtom {
obj1, "test", obj2
};
listAtom.GetObject(1).Should().BeNull();
}
public void ListAtomGetObjectTest()
{
var obj1 = new object();
var obj2 = new object();
var obj3 = new object();
var listAtom = new ListAtom {
obj1, obj2, obj3
};
listAtom.GetObject(1).Should().Be(obj2);
}
public void ListAtomGetListInvalidTest()
{
var atom1 = new ListAtom {
"Tester tester 1 2 3"
};
var listAtom = new ListAtom {
atom1, "test"
};
listAtom.GetList(1).Should().BeNull();
}
public void ListAtomClearTest()
{
var atom = new ListAtom {
15, 25
};
atom.Count.Should().Be(2);
atom.Clear();
atom.Count.Should().Be(0);
}
public void ListAtomGetDictionaryInvalidTest()
{
var atom1 = new DictionaryAtom();
atom1.Set("Test1", "Tester tester 1 2 3");
var listAtom = new ListAtom {
atom1, "test"
};
listAtom.GetDictionary(1).Should().BeNull();
}
/// <summary>
/// Executes the provided transaction
/// </summary>
private TransactionResponse ExecuteNextTransaction(CancellationToken token, PendingTransaction transaction)
{
Validation.IsNotNull(token, "token");
Validation.IsNotNull(transaction, "transaction");
token.ThrowIfCancellationRequested();
var success = true;
var commandResults = new ListAtom();
transaction.State = TransactionState.Executing;
var sqlTransaction = _connection.BeginTransaction();
try
{
using (var it = transaction.DbCommands.GetEnumerator())
{
while (it.MoveNext())
{
var dbCommand = it.Current.CastAs <DictionaryAtom>();
if (!success)
{
continue;
}
var resultSet = ExecuteProcedure(dbCommand);
if (resultSet == null || (resultSet.ContainsKey("success") && !resultSet.GetBool("success")))
{
success = false;
}
commandResults.Add(resultSet ?? new DictionaryAtom());
}
}
}
catch (SqlException ex)
{
ex.Handle(ExceptionHandlingOptions.RecordOnly, _log);
success = false;
}
finally
{
TryRollbackOrCommit(sqlTransaction, success);
}
SetResultSetSuccess(commandResults, success);
return(new TransactionResponse
{
Success = success,
CommandResults = commandResults
});
}
/// <summary>
/// Converts a datatable to a listatom
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public static ListAtom ToListAtom(this DataTable table)
{
var resultList = new ListAtom();
table.Rows.OfType <DataRow>().ToList().ForEach(row =>
{
var rowResult = new DictionaryAtom();
table.Columns.OfType <DataColumn>().ToList().ForEach(col => rowResult.Set(col.ColumnName, row[col]));
resultList.Add(rowResult);
});
return(resultList);
}
public void ListAtomGetListTest()
{
var atom1 = new ListAtom {
"Tester tester 1 2 3"
};
var atom2 = new ListAtom {
"This is a big test"
};
var listAtom = new ListAtom {
atom1, atom2
};
listAtom.GetList(1).Should().BeSameAs(atom2);
}
/// <summary>
/// Do initialization that cannot be done at construction
/// </summary>
public void OnInit(DictionaryAtom args)
{
Validation.IsNotNull(args, "args");
_connectionString = args.GetString("ConnectionString");
Validation.IsNotNullOrEmpty(_connectionString, "_connectionString");
_numberServers = args.GetInt("NumberDBServers");
Validation.Validate <ArgumentOutOfRangeException>(_numberServers >= 1);
_log.DebugFormat("{0} asked to spin up {1} database servers.", GetType(), _numberServers);
InitDatabaseLoaders(args);
_loaderArgs = args.GetAtom <ListAtom>("Loaders");
_eventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
}
public void ListAtomGetDictionaryTest()
{
var atom1 = new DictionaryAtom();
atom1.Set("Test1", "Tester tester 1 2 3");
var atom2 = new DictionaryAtom();
atom2.Set("Test2", "This is a big test");
var listAtom = new ListAtom {
atom1, atom2
};
listAtom.GetDictionary(1).Should().Be(atom2);
}
public void ListAtomGetAtomTest()
{
var atom1 = new IntAtom(15);
var atom2 = new IntAtom(25);
var atom3 = new IntAtom(35);
var listAtom = new ListAtom {
atom1, atom2, atom3
};
listAtom.Count.Should().Be(3);
var actual = listAtom.Get(1);
actual.Should().NotBeNull();
actual.Should().Be(atom2);
}
public void ListAtomDumpTest()
{
var callback = false;
var logger = A.Fake <ILogWrapper>();
A.CallTo(() => logger.InfoFormat(A <string> .Ignored, A <object> .Ignored))
.Invokes(() => callback = true);
var atom = new ListAtom();
const string prefix = "Test";
atom.Dump(logger, prefix);
callback.Should().BeTrue();
}
public void SetListAtom()
{
var listAtom = new ListAtom {
"1 2 3 4 5"
};
var atom = new DictionaryAtom();
atom.Set("TestList", listAtom);
atom.ContainsKey("TestList").Should().BeTrue();
var foundAtom = atom.GetAtom <ListAtom>("TestList");
foundAtom.Should().NotBeNull();
foundAtom.Should().BeAssignableTo <ListAtom>();
foundAtom.GetString(0).Should().Be("1 2 3 4 5");
}
public void ListAtomGetEnumeratorTest()
{
var listAtom = new ListAtom {
15, 25, 35
};
var enumerator = listAtom.GetEnumerator();
enumerator.Should().NotBeNull();
var runningTotal = 0;
while (enumerator.MoveNext())
{
var valueAtom = (IntAtom)enumerator.Current;
runningTotal += valueAtom.Value;
}
runningTotal.Should().Be(75);
}
