public void JoinGlobakKTable()
{
var source = new CancellationTokenSource();
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-config";
config.PollMs = 10;
var topicConfiguration = config.Clone();
topicConfiguration.ApplicationId = $"test-driver-{config.ApplicationId}";
var builder = new StreamBuilder();
var globalktable = builder.GlobalTable("test", InMemory <string, string> .As("global-store"));
builder.Stream <string, string>("source")
.Join(globalktable,
(k, v) => k,
(v1, v2) => $"{v1}-{v2}")
.To("sink");
var driver = new ClusterInMemoryTopologyDriver("client", builder.Build().Builder, config, topicConfiguration, TimeSpan.FromSeconds(1), source.Token);
driver.StartDriver();
var inputTest = driver.CreateInputTopic("test", new StringSerDes(), new StringSerDes());
var inputSource = driver.CreateInputTopic("source", new StringSerDes(), new StringSerDes());
var output = driver.CreateOutputTopic("sink", TimeSpan.FromSeconds(1), new StringSerDes(), new StringSerDes());
inputTest.PipeInput("coucou", "Sylvain");
Thread.Sleep(100);
inputSource.PipeInput("coucou", "Coucou");
Thread.Sleep(300);
var records = IntegrationTestUtils.WaitUntilMinKeyValueRecordsReceived(output, 1);
Assert.AreEqual(1, records.Count);
Assert.AreEqual("Coucou-Sylvain", records.First().Message.Value);
source.Cancel();
driver.Dispose();
}
public void GlobalTableWithStoreQueryable()
{
var builder = new StreamBuilder();
var table = builder.GlobalTable("topic", InMemory <string, string> .As("global-store"));
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-globaltable";
Topology t = builder.Build();
using (var driver = new TopologyTestDriver(t, config))
{
var inputTopic = driver.CreateInputTopic <string, string>("topic");
inputTopic.PipeInput("test", "coucou");
var store = driver.GetKeyValueStore <string, string>("global-store");
var ele = store.Get("test");
Assert.IsNotNull(ele);
Assert.AreEqual("coucou", ele);
}
}
public void TestAdd()
{
// Arrange
var harness = new InMemory();
var expected = new Blab {
Id = 1,
CreatedBy = -1,
CreatedDate = DateTime.Now,
LastModifiedBy = null,
LastModifiedDate = null,
Message = "This is a really cool app!",
UserId = 1
};
// Act
harness.Create(expected);
var actual = harness.Read(0);
// Assert
Assert.AreEqual(expected, actual);
}
public void Init()
{
token1 = new System.Threading.CancellationTokenSource();
token2 = new System.Threading.CancellationTokenSource();
config.ApplicationId = "test-stream-thread";
config.StateDir = Path.Combine(".", Guid.NewGuid().ToString());
config.Guarantee = ProcessingGuarantee.AT_LEAST_ONCE;
config.PollMs = 10;
mockKafkaSupplier = new MockKafkaSupplier(2, 0);
var builder = new StreamBuilder();
builder.Table("topic", InMemory <string, string> .As("store").WithLoggingEnabled());
var topo = builder.Build();
topo.Builder.RewriteTopology(config);
topo.Builder.BuildTopology();
thread1 = StreamThread.Create(
"thread-0", "c0",
topo.Builder, new StreamMetricsRegistry(), config,
mockKafkaSupplier, mockKafkaSupplier.GetAdmin(config.ToAdminConfig("admin")),
0) as StreamThread;
thread2 = StreamThread.Create(
"thread-1", "c1",
topo.Builder, new StreamMetricsRegistry(), config,
mockKafkaSupplier, mockKafkaSupplier.GetAdmin(config.ToAdminConfig("admin")),
1) as StreamThread;
var internalTopicManager =
new DefaultTopicManager(config, mockKafkaSupplier.GetAdmin(config.ToAdminConfig("admin")));
InternalTopicManagerUtils
.New()
.CreateInternalTopicsAsync(internalTopicManager, topo.Builder).GetAwaiter();
}
public async Task CreateAsync_ShouldReturnModifiedBreweryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnModifiedBreweryDTOAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery"
}
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
var result = await sut.CreateAsync(breweryDTO);
var dbresult = await context.Breweries.FirstOrDefaultAsync(c => c.Name == "Brewery");
//Assert
Assert.AreEqual(result.ID, dbresult.ID);
Assert.AreEqual(result.Name, dbresult.Name);
}
}
public async Task GetAsync_ShouldReturnNullIfBreweryModelConversionFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAsync_ShouldReturnNullIfBreweryModelConversionFailsAsync");
using (var context = new BOContext(options))
{
var brewery = new Brewery();
context.Breweries.Add(brewery);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BreweryServices(context);
var result = await sut.GetAsync(1);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task GetAsync_ShouldReturnNullIfModelStyleConversionFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAsync_ShouldReturnNullIfModelStyleConversionFailsAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle();
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
var result = await sut.GetAsync(1);
//Assert
Assert.AreEqual(result, null);
}
}
public void KTableSourceKeyNull()
{
var builder = new StreamBuilder();
builder.Table("table-topic", InMemory <string, string> .As("table-topic-store"));
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-map";
Topology t = builder.Build();
using var driver = new TopologyTestDriver(t, config);
var inputTopic = driver.CreateInputTopic <string, string>("table-topic");
inputTopic.PipeInput(null, "1");
var store = driver.GetKeyValueStore <string, string>("table-topic-store");
Assert.IsNotNull(store);
Assert.AreEqual(0, store.ApproximateNumEntries());
}
public void GetStateStoreExist()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-config";
var builder = new StreamBuilder();
builder.Table <string, string>("test", InMemory <string, string> .As("store"));
var driver = new TaskSynchronousTopologyDriver("client", builder.Build().Builder, config, config, default);
var input = driver.CreateInputTopic("test", new StringSerDes(), new StringSerDes());
var store = driver.GetStateStore <string, string>("store");
Assert.IsNotNull(store);
Assert.IsInstanceOf <ReadOnlyKeyValueStore <string, ValueAndTimestamp <string> > >(store);
input.PipeInput("coucou", "1");
Assert.AreEqual(1, ((ReadOnlyKeyValueStore <string, ValueAndTimestamp <string> >)store).All().Count());
Assert.AreEqual("1", ((ReadOnlyKeyValueStore <string, ValueAndTimestamp <string> >)store).Get("coucou").Value);
driver.Dispose();
}
public void KeySerdesUnknow()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-count";
var builder = new StreamBuilder();
builder
.Stream <string, string>("topic")
.GroupBy((k, v) => k.ToCharArray()[0])
.Count(InMemory <char, long> .As("count-store"));
var topology = builder.Build();
Assert.Throws <StreamsException>(() =>
{
using var driver = new TopologyTestDriver(topology, config);
var input = driver.CreateInputTopic <string, string>("topic");
input.PipeInput("test", "1");
});
}
public void KTableToStreamWithDelete()
{
var builder = new StreamBuilder();
builder.Table("table-topic", InMemory <string, string> .As("table-topic-store"))
.ToStream().To("table-stream");
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-map";
Topology t = builder.Build();
using var driver = new TopologyTestDriver(t, config);
var inputTopic = driver.CreateInputTopic <string, string>("table-topic");
var outputTopic = driver.CreateOuputTopic <string, string>("table-stream");
var expected = new List <KeyValuePair <string, string> >();
expected.Add(KeyValuePair.Create("key1", "a"));
expected.Add(KeyValuePair.Create("key2", "b"));
expected.Add(KeyValuePair.Create("key2", (string)null));
inputTopic.PipeInput("key1", "a");
inputTopic.PipeInput("key2", "b");
inputTopic.PipeInput("key2", null);
var store = driver.GetKeyValueStore <string, string>("table-topic-store");
Assert.IsNotNull(store);
var resultK1 = store.Get("key1");
var resultK2 = store.Get("key2");
Assert.AreEqual("a", resultK1);
Assert.AreEqual(null, resultK2);
var results = outputTopic.ReadKeyValueList().Select(r => KeyValuePair.Create(r.Message.Key, r.Message.Value));
Assert.AreEqual(expected, results);
}
public async Task GetAllAsync_ShouldReturnNullIfModelHasNoNameFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnNullIfModelHasNoNameFailsAsync");
using (var context = new BOContext(options))
{
var country = new Country();
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CountriesService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.AreEqual(result, null);
}
}
public async Task GetAllAsync_ShouldReturnNullIfModelReviewHasNoBeerOrUserFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnNullIfModelReviewHasNoBeerOrUserFailsAsync");
using (var context = new BOContext(options))
{
var review = new Review();
context.Reviews.Add(review);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new ReviewsService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.AreEqual(result, null);
}
}
public void TableTableJoinStateStore()
{
var config = new StreamConfig <StringSerDes, StringSerDes>
{
ApplicationId = "test-table-table-join"
};
StreamBuilder builder = new StreamBuilder();
var table1 = builder.Table("table1", InMemory <string, string> .As("store1"));
var table2 = builder.Table("table2", InMemory <string, string> .As("store2"));
var tableJoin = table1.Join(table2, (v1, v2) => $"{v1}-{v2}", InMemory <string, string> .As("merge-store"));
tableJoin.ToStream().To("topic-output");
Topology t = builder.Build();
using (var driver = new TopologyTestDriver(t, config))
{
var inputTopic1 = driver.CreateInputTopic <string, string>("table1");
var inputTopic2 = driver.CreateInputTopic <string, string>("table2");
var outputTopic = driver.CreateOuputTopic <string, string>("topic-output");
inputTopic1.PipeInput("test", "test");
inputTopic2.PipeInput("test", "coucou");
var st1 = driver.GetKeyValueStore <string, string>("store1");
var st2 = driver.GetKeyValueStore <string, string>("store2");
var mergeStore = driver.GetKeyValueStore <string, string>("merge-store");
Assert.AreEqual(1, st1.ApproximateNumEntries());
Assert.AreEqual(1, st2.ApproximateNumEntries());
Assert.AreEqual(1, mergeStore.ApproximateNumEntries());
Assert.AreEqual("test", st1.Get("test"));
Assert.AreEqual("coucou", st2.Get("test"));
Assert.AreEqual("test-coucou", mergeStore.Get("test"));
}
}
public void Update_Success()
{
// Arrange
var mockDbSet = new Mock <DbSet <TestEntity> >();
mockDbSet.Setup(d => d.Update(It.IsAny <TestEntity>()));
var mockContext = new Mock <IContext>();
mockContext.Setup(c => c.Set <TestEntity>()).Returns(mockDbSet.Object);
mockContext.Setup(c => c.SaveChanges());
var inMemory = new InMemory <TestEntity>(mockContext.Object);
// Act
inMemory.Update(new TestEntity());
// Assert
mockDbSet.Verify(d => d.Update(It.IsAny <TestEntity>()), Times.Once);
mockContext.Verify(c => c.Set <TestEntity>(), Times.Once);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
}
public void DeleteUserShould_ReturnTrue_whenDeletedUser()
{
//Arrange
var options = InMemory.GetOptions("DeleteUserShould_ReturnTrue_whenDeletedUser");
using (var context = new BOContext(options))
{
var cut = new User()
{
Id = 1,
Name = "SuperMan",
Password = "******",
};
var user = new User()
{
Id = 2,
Name = "Batman",
Password = "******",
};
context.Users.Add(cut);
context.Users.Add(user);
context.SaveChanges();
}
using (var context = new BOContext(options))
{
//Act
var sut = new UsersService(context);
var result = sut.DeleteUser(1).Result;
//Assert
var deletedUsers = context.Users.Where(u => u.IsDeleted == true).Count();
var activeUsers = context.Users.Where(u => u.IsDeleted == false).Count();
Assert.IsTrue(result);
Assert.AreEqual(1, deletedUsers);
Assert.AreEqual(1, activeUsers);
}
}
public void KTableSourceDelete()
{
var builder = new StreamBuilder();
builder.Table("table-topic", InMemory <string, string> .As("table-topic-store"));
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-map";
Topology t = builder.Build();
using var driver = new TopologyTestDriver(t, config);
var inputTopic = driver.CreateInputTopic <string, string>("table-topic");
inputTopic.PipeInput("key1", "1");
inputTopic.PipeInput("key2", "2");
var store = driver.GetKeyValueStore <string, string>("table-topic-store");
Assert.IsNotNull(store);
var resultK1 = store.Get("key1");
var resultK2 = store.Get("key2");
Assert.AreEqual(2, store.All().Count());
Assert.AreEqual("1", resultK1);
Assert.AreEqual("2", resultK2);
inputTopic.PipeInput("key1", null);
resultK1 = store.Get("key1");
resultK2 = store.Get("key2");
Assert.AreEqual(1, store.All().Count());
Assert.AreEqual(null, resultK1);
Assert.AreEqual("2", resultK2);
}
public void TableTableJoinGetterSupplier()
{
var config = new StreamConfig <StringSerDes, StringSerDes>
{
ApplicationId = "test-table-table-join"
};
StreamBuilder builder = new StreamBuilder();
var table1 = builder.Table("users", InMemory <string, string> .As("store-users"));
var table2 = builder.Table("regions", InMemory <string, string> .As("store-regions"));
var stream = builder.Stream <string, string>("orders");
var tableJoin = table1.Join(table2, (v1, v2) => $"{v1}-{v2}");
stream
.Join(tableJoin, (order, ur) => $"Order:{order}|UserRegion:{ur}")
.To("topic-output");
Topology t = builder.Build();
using (var driver = new TopologyTestDriver(t, config))
{
var inputTopic1 = driver.CreateInputTopic <string, string>("users");
var inputTopic2 = driver.CreateInputTopic <string, string>("regions");
var inputTopic3 = driver.CreateInputTopic <string, string>("orders");
var outputTopic = driver.CreateOuputTopic <string, string>("topic-output");
inputTopic1.PipeInput("sylvain", "sylvain");
inputTopic2.PipeInput("sylvain", "France");
inputTopic3.PipeInput("sylvain", "iPhone12Pro");
var record = outputTopic.ReadKeyValue();
Assert.IsNotNull(record);
Assert.AreEqual("sylvain", record.Message.Key);
Assert.AreEqual("Order:iPhone12Pro|UserRegion:sylvain-France", record.Message.Value);
}
}
public async void process(IConfiguration config)
{
var sConfig = new StreamConfig <StringSerDes, StringSerDes>();
sConfig.ApplicationId = config["SPRING_CLOUD_APPLICATION_GUID"];
sConfig.BootstrapServers = config["SPRING_CLOUD_STREAM_KAFKA_BINDER_BROKERS"];
StreamBuilder builder = new StreamBuilder();
var table = builder.Table("product",
new StringSerDes(),
new StringSerDes(),
InMemory <String, String> .As("product-store"));
builder.Stream <String, String, StringSerDes, StringSerDes>(config["spring.cloud.stream.bindings.input.destination"])
.Join(table, (order, product) => order + product)
.To(config["spring.cloud.stream.bindings.output.destination"]);
Topology t = builder.Build();
KafkaStream stream = new KafkaStream(t, sConfig);
await stream.StartAsync();
}
public async Task UpdateAsync_ShouldReturnNullIfCountryNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfCountryNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var countryDTO = new CountryDTO()
{
Name = "Bulgaria"
};
//Act
var sut = new CountriesService(context);
var result = await sut.UpdateAsync(1, countryDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public async Task CreateAsync_ShouldReturnCountryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnCountryDTOAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var countryDTO = new CountryDTO()
{
Name = "Bulgaria"
};
//Act
var sut = new CountriesService(context);
var result = await sut.CreateAsync(countryDTO);
//Assert
Assert.IsInstanceOfType(result, typeof(CountryDTO));
}
}
public async Task CreateAsync_ShouldReturnBreweryDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldReturnBreweryDTOAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery"
}
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var breweryDTO = new BreweryDTO()
{
Name = "Brewery",
Country = "Bulgaria"
};
//Act
var sut = new BreweryServices(context);
var result = await sut.CreateAsync(breweryDTO);
//Assert
Assert.IsInstanceOfType(result, typeof(BreweryDTO));
}
}
public void Reduce5()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-count";
var builder = new StreamBuilder();
builder
.Stream <string, string>("topic")
.GroupBy((k, v) => k?.ToUpper())
.Reduce(
new MyReducer(),
InMemory <string, string> .As("reduce-store"),
"reduce-processor");
var topology = builder.Build();
using var driver = new TopologyTestDriver(topology, config);
var input = driver.CreateInputTopic <string, string>("topic");
input.PipeInput("test", "1");
input.PipeInput("test", null);
input.PipeInput(null, "34");
input.PipeInput(null, null);
input.PipeInput("test", "12");
var store = driver.GetKeyValueStore <string, string>("reduce-store");
Assert.IsNotNull(store);
// null doesn't matter
Assert.AreEqual(1, store.ApproximateNumEntries());
var el = store.Get("TEST");
Assert.IsNotNull(el);
Assert.AreEqual("12", el);
}
public async Task DeleteAsync_ShouldDeleteCommentIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteCommentIfExist");
using (var context = new BOContext(options))
{
var comment = new Comment
{
Description = "Gotham",
User = new User()
{
Name = "Batman"
},
Review = new Review()
{
Description = "Description"
}
};
context.Comments.Add(comment);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new CommentService(context);
await sut.DeleteAsync(1);
var dbresult = await context.Comments.FirstOrDefaultAsync(c => c.ReviewID == 1 && c.UserID == 1);
//Assert
Assert.AreEqual(dbresult.Description, "Gotham");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
}
}
private static void Main(string[] args)
{
InMemory myNewCache = new InMemory();
string strFilePath = System.IO.Path.Combine(Environment.CurrentDirectory, "../../XmlFiles/ListOfUsers.xml");
var lstFiles = new List <string>();
lstFiles.Add(strFilePath);
//for (int i = 1; i <= 100; i++)
//{
// string cacheItem1 = "Steve Smith-" + i;
// myNewCache.AddToMyCache(i.ToString(CultureInfo.InvariantCulture), cacheItem1, MyCachePriority.NotRemovable, lstFiles);
//}
Console.WriteLine(DateTime.Now.ToString(CultureInfo.InvariantCulture));
for (int i = 1; i <= 250000; i++)
{
var car = new Car("Blue" + i, i);
myNewCache.AddToMyCache(
i.ToString(CultureInfo.InvariantCulture), car, MyCachePriority.NotRemovable, lstFiles);
}
var myItem10 = myNewCache.GetMyCachedItem("10") as Car;
var myItem100 = myNewCache.GetMyCachedItem("100") as Car;
var myItem1000 = myNewCache.GetMyCachedItem("1000") as Car;
var myItem10000 = myNewCache.GetMyCachedItem("10000") as Car;
var myItem100000 = myNewCache.GetMyCachedItem("100000") as Car;
var myItem150000 = myNewCache.GetMyCachedItem("150000") as Car;
var myItem200000 = myNewCache.GetMyCachedItem("200000") as Car;
var myItem250000 = myNewCache.GetMyCachedItem("250000") as Car;
Console.WriteLine(DateTime.Now.ToString(CultureInfo.InvariantCulture) + " (" + myNewCache.Count() + ")");
while (Console.ReadLine() != "quit")
{
}
}
public async Task CreateAsync_ShouldUndeleteStyleRecordIfExist()
{
//Arrange
var options = InMemory.GetOptions("CreateAsync_ShouldUndeleteStyleRecordIfExist");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description",
DeletedOn = DateTime.UtcNow,
IsDeleted = true
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale",
Description = "This description"
};
//Act
var sut = new BeerStylesService(context);
await sut.CreateAsync(styleDTO);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(dbresult.Name, "Ale");
Assert.AreEqual(dbresult.DeletedOn, null);
Assert.AreEqual(dbresult.IsDeleted, false);
}
}
public async Task UpdateAsync_ShouldReturnNullIfBeerNonExistantAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldReturnNullIfBeerNonExistantAsync");
using (var context = new BOContext(options))
{
}
using (var context = new BOContext(options))
{
var beerDTO = new BeerDTO()
{
ABV = 4.5f,
Rating = 2,
Name = "Carlsberg",
Country = new CountryDTO()
{
Name = "Germany"
},
Style = new BeerStyleDTO()
{
Name = "Ale"
},
Brewery = new BreweryDTO()
{
Name = "Brewery"
}
};
//Act
var sut = new BeerService(context);
var result = await sut.UpdateAsync(1, beerDTO);
//Assert
Assert.AreEqual(result, null);
}
}
public void UpdateUserAsyncShould_ReturnCorrectUser()
{
//Arrange
var options = InMemory.GetOptions("UpdateUserAsyncShould_ReturnCorrectUser");
using (var context = new BOContext(options))
{
var cut = new User()
{
Id = 1,
Name = "SuperMan",
Password = "******",
ReviewList = new List <Review>(),
CommentList = new List <Comment>(),
DrankLists = new List <DrankList>(),
WishLists = new List <WishList>(),
};
context.Users.Add(cut);
context.SaveChanges();
}
var updatedUser = new UserDTO()
{
Name = "Batman",
Password = "******",
};
using (var context = new BOContext(options))
{
//Act
var sut = new UsersService(context);
var result = sut.UpdateUserAsync(1, updatedUser).Result;
//Assert
Assert.AreEqual(updatedUser.Name, result.Name);
Assert.AreEqual(updatedUser.Password, result.Password);
//Assert.IsNotNull(result.ModifiedOn);
}
}
public void TestGetWindowStoreKeyValueStore()
{
var config = new StreamConfig <StringSerDes, StringSerDes>();
config.ApplicationId = "test-window-stream";
var builder = new StreamBuilder();
builder
.Stream <string, string>("topic")
.GroupByKey()
.Count(InMemory <string, long> .As("count-store"));
var topology = builder.Build();
using var driver = new TopologyTestDriver(topology, config);
DateTime dt = DateTime.Now;
var input = driver.CreateInputTopic <string, string>("topic");
input.PipeInput("test", "1", dt);
var store = driver.GetWindowStore <string, long>("count-store");
Assert.IsNull(store);
}
public async Task GetAsync_ShouldReturnNullIfBeerModelConversionFailsAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAsync_ShouldReturnNullIfBeerModelConversionFailsAsync");
using (var context = new BOContext(options))
{
var country = new Country()
{
Name = "Bulgaria",
Breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Brewery",
Beers = new List <Beer>()
{
new Beer()
}
}
}
};
context.Countries.Add(country);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerService(context);
var result = await sut.GetAsync(1);
//Assert
Assert.AreEqual(result, null);
}
}
