public void should_spawn_new_pawn()
{
// Setup
var graphContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
graphContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
// Act
Bls bls = new Bls(null, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
BasicPawn basicPawn = bls.SpawnNew <BasicPawn>();
// Assert
Assert.NotNull(basicPawn);
Assert.Single(bls.ToAddBuffer);
}
public void should_be_able_to_find_pawns_if_sort_parameter_is_supplied()
{
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn",
Properties = new List <BlContainerProp>()
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider => provider.FindInContainer <BasicPawn>(It.IsAny <string>(), null, "Name", "Asc", 200))
.Returns(cursor).Verifiable();
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var resultCursor = bls.Find <BasicPawn>(filter: null, sortProperty: p => p.Name);
// Assert
Assert.NotNull(resultCursor);
storageProviderMock.Verify();
}
internal string CreatePawnTable(BlGraphContainer container)
{
var builder = new StringBuilder($"CREATE TABLE {container.StorageContainerName}\n");
builder.Append("(Id INTEGER PRIMARY KEY, \n");
foreach (BlContainerProp prop in container.Properties)
{
Type type = prop.PropType;
if (type == typeof(string))
{
builder.Append($"{prop.Name} TEXT, \n");
}
else if (type == typeof(int) || type == typeof(uint) || type == typeof(short) || type == typeof(long))
{
builder.Append($"{prop.Name} INTEGER, \n");
}
else if (type == typeof(byte) || type == typeof(sbyte) || type == typeof(bool))
{
builder.Append($"{prop.Name} INTEGER, \n");
}
else if (type == typeof(float) || type == typeof(double) || type == typeof(decimal))
{
builder.Append($"{prop.Name} REAL, \n");
}
}
builder.Append(");");
builder.Replace(", \n)", ")");
return(builder.ToString());
}
public void should_not_be_able_to_get_pawn_by_id_if_its_not_registered()
{
// Setup
var basicPawn = new BasicPawn {
Name = "Name"
};
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn", StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider => provider.GetById <BasicPawn>(It.IsAny <string>(), null))
.Returns(basicPawn);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
// Act & Assert
Assert.Throws <PawnNotRegisteredError>(() =>
{
bls.GetById <BasicPawn>("123");
});
}
public void should_fail_on_find_if_single_filter_property_is_incorrectly_formatted()
{
// There is some strange lambda syntax here which people would probably never use but it's
// still a good idea to guard against these types of error
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn", StorageContainerName = "BasicPawn"
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock
.Setup(provider =>
provider.FindInContainer <BasicPawn>(It.IsAny <string>(), It.IsAny <BlBinaryExpression>(), null,
"Asc", 200))
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act & Assert
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
// ReSharper disable once EqualExpressionComparison
bls.Find <BasicPawn>(filter: (pawn => "" == ""));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => "" == pawn.Name));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => string.Empty == ""));
});
Assert.Throws <IncorrectFilterArgumentStructureError>(() =>
{
bls.Find <BasicPawn>(filter: (pawn => true));
});
}
public void should_be_able_to_find_pawns_based_on_single_literal_filter()
{
// Setup
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn",
Properties = new List <BlContainerProp>()
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var cursor = new StorageCursor <BasicPawn>();
var storageProviderMock = new Mock <IBlStorageProvider>();
BlBinaryExpression filterExpression = null;
storageProviderMock
.Setup(provider =>
provider.FindInContainer <BasicPawn>(It.IsAny <string>(), It.IsAny <BlBinaryExpression>(), null,
"Asc", 200))
.Callback <string, BlBinaryExpression, string, string, int>((container, exp, sort, order, batchSize) =>
filterExpression = exp)
.Returns(cursor);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var resultCursor = bls.Find <BasicPawn>(filter: (bp) => bp.Name == "some name");
// Assert
Assert.NotNull(resultCursor);
Assert.NotNull(filterExpression);
Assert.Equal("Name", filterExpression.PropName);
Assert.Equal(BlOperator.Eq, filterExpression.Operator);
Assert.Equal("some name", filterExpression.Value);
Assert.Null(filterExpression.Left);
Assert.Null(filterExpression.Right);
Assert.True(filterExpression.IsLeaf);
}
public void should_be_able_to_get_pawn_by_id()
{
// Setup
var basicPawn = new BasicPawn {
Name = "Name"
};
basicPawn.SetId("123_id");
var basicPawnContainer = new BlGraphContainer
{
BlContainerName = "BasicPawn",
StorageContainerName = "BasicPawn",
Properties = new List <BlContainerProp>()
};
var containerList = new List <BlGraphContainer> {
basicPawnContainer
};
var graphMock = new Mock <IBlGraph>();
graphMock.Setup(graph => graph.GetStorageContainerNameForPawn(It.IsAny <BasicPawn>())).Returns("BasicPawn");
graphMock.Setup(graph => graph.CompiledCollections).Returns(containerList);
var storageProviderMock = new Mock <IBlStorageProvider>();
storageProviderMock.Setup(provider
=> provider.GetById <BasicPawn>(It.IsAny <string>(), It.IsAny <string>())).Returns(basicPawn);
var bls = new Bls(storageProviderMock.Object, graphMock.Object);
bls.RegisterBlPawns(new BasicPawn());
// Act
var found = bls.GetById <BasicPawn>("123");
// Assert
Assert.NotNull(found);
storageProviderMock.Verify(provider => provider.GetById <BasicPawn>("123", "BasicPawn"), Times.Once());
}
public void should_create_query_for_new_table()
{
// Setup
var container = new BlGraphContainer
{
BlContainerName = "TestPawn",
StorageContainerName = "test_pawn",
Properties = new List <BlContainerProp>
{
new BlContainerProp {
Name = "StrProp", PropType = typeof(string)
},
new BlContainerProp {
Name = "IntProp", PropType = typeof(int)
},
new BlContainerProp {
Name = "UIntProp", PropType = typeof(uint)
},
new BlContainerProp {
Name = "ShortProp", PropType = typeof(short)
},
new BlContainerProp {
Name = "LongProp", PropType = typeof(long)
},
new BlContainerProp {
Name = "FloatProp", PropType = typeof(float)
},
new BlContainerProp {
Name = "DecimalProp", PropType = typeof(decimal)
},
new BlContainerProp {
Name = "DoubleProp", PropType = typeof(double)
},
new BlContainerProp {
Name = "ByteProp", PropType = typeof(byte)
},
new BlContainerProp {
Name = "SByteProp", PropType = typeof(sbyte)
},
new BlContainerProp {
Name = "BoolProp", PropType = typeof(bool)
}
}
};
var builder = new SqlQueryBuilder();
// Act
string createTableCommand = builder.CreatePawnTable(container);
// Assert
var statement = @"CREATE TABLE test_pawn (
Id INTEGER PRIMARY KEY,
StrProp TEXT,
IntProp INTEGER,
UIntProp INTEGER,
ShortProp INTEGER,
LongProp INTEGER,
FloatProp REAL,
DecimalProp REAL,
DoubleProp REAL,
ByteProp INTEGER,
SByteProp INTEGER,
BoolProp INTEGER
);";
Assert.Equal(
statement.Replace("\n", "").Replace("\r", "").Replace(" ", ""),
createTableCommand.Replace("\n", "").Replace("\r", "").Replace(" ", ""));
}
[ExcludeFromCodeCoverage] // returns simple string
internal string DropTable(BlGraphContainer container)
{
return($"DROP TABLE {container.StorageContainerName};");
}
