public void WhenEventWithTaskNameInAttributeIsRaised()
{
this.tableName = "WhenEventWithTaskNameInAttributeIsRaised";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(10));
listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All);
logger.CriticalWithTaskName("Critical with task name");
logger.CriticalWithKeywordPage("Critical with no task name");
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 2);
Assert.AreEqual(2, events.Count());
Assert.AreEqual("64513", events.First().Task.ToString());
Assert.AreEqual("1", events.ElementAt(1).Task.ToString());
}
public void WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised()
{
this.tableName = "WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(10));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.ErrorWithKeywordDiagnostic("Error with keyword EventlogClassic");
}
finally
{
listener.DisableEvents(logger);
}
}
var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(0, eventsCount);
}
public void WhenLoggingMultipleMessages()
{
this.tableName = "WhenLoggingMultipleMessages";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName);
listener.EnableEvents(logger, EventLevel.LogAlways);
for (int n = 0; n < 300; n++)
{
logger.Informational("logging multiple messages " + n.ToString());
}
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 300);
Assert.AreEqual(300, events.Count());
}
public void WhenDefaultTableNameIsUsed()
{
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, WindowsAzureTableLog.DefaultTableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, bufferingInterval: TimeSpan.FromSeconds(1));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.Error("This is an error message");
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, WindowsAzureTableLog.DefaultTableName, 1);
Assert.AreEqual(1, events.Count());
}
public void WhenEventHasMultiplePayloads()
{
this.tableName = "WhenEventHasMultiplePayloads";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.EventWithMultiplePayloads("TestPayload 1", "TestPayload 2", "TestPayload 3");
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
StringAssert.Contains(events.First().Payload, @"""payload1"": ""TestPayload 1""");
StringAssert.Contains(events.First().Payload, @"""payload2"": ""TestPayload 2""");
StringAssert.Contains(events.First().Payload, @"""payload3"": ""TestPayload 3""");
}
public void WhenEventHasAllValuesForAttribute()
{
this.tableName = "WhenEventHasAllValuesForAttribute";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1));
listener.EnableEvents(logger, EventLevel.LogAlways, Keywords.All);
logger.AllParametersWithCustomValues();
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
Assert.AreEqual(10001, events.ElementAt(0).EventId);
}
public void WhenEventWithEnumsInPayloadIsRaised()
{
this.tableName = "WhenEventWithEnumsInPayloadIsRaised";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = MockEventSourceInProcEnum.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.Zero);
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.SendEnumsEvent17(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag2);
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
Assert.AreEqual((int)EventTask.None, events.ElementAt(0).Task);
Assert.AreEqual((int)EventOpcode.Resume, events.ElementAt(0).Opcode);
Assert.AreEqual("{\n \"a\": 2,\n \"b\": 2\n}", events.ElementAt(0).Payload.ToString());
}
public void WhenEventsWithDifferentLevels()
{
this.tableName = "WhenEventsWithDifferentLevels";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.Critical("This is a critical message");
logger.Error("This is an error message");
logger.Informational("This is informational");
});
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 3);
Assert.AreEqual(3, events.Count());
Assert.AreEqual(TestEventSource.InformationalEventId, events.ElementAt(0).EventId);
Assert.AreEqual(TestEventSource.ErrorEventId, events.ElementAt(1).EventId);
Assert.AreEqual(TestEventSource.CriticalEventId, events.ElementAt(2).EventId);
}
public void WhenUsingAzureTable()
{
this.tableName = "azuretablese2eusingwindowsservice";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
string configFile = "Configurations\\WinService\\AzureTablesWinService.xml";
IEnumerable <WindowsAzureTableEventEntry> events = null;
try
{
StartServiceWithConfig(configFile);
var logger = MockEventSourceOutProc.Logger;
logger.LogSomeMessage("logging using windows service to azure tables");
logger.LogSomeMessage("logging using windows service to azure tables 2");
events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 2);
}
finally
{
StopService();
}
Assert.AreEqual(2, events.Count());
var event1 = events.SingleOrDefault(e => e.Payload.Contains(@"""message"": ""logging using windows service to azure tables"""));
Assert.IsNotNull(event1);
var event2 = events.SingleOrDefault(e => e.Payload.Contains(@"""message"": ""logging using windows service to azure tables 2"""));
Assert.IsNotNull(event2);
}
public void WhenUsingAzureTable()
{
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, End2EndFixtureBase.AzureTableName);
string configFile = CopyConfigFileToWhereServiceExeFileIsLocatedAndReturnNewConfigFilePath("Configurations\\WinService", "AzureTablesWinService.xml");
IEnumerable <WindowsAzureTableEventEntry> events = null;
var logger = MockEventSourceOutProc.Logger;
this.ExecuteServiceTest(configFile, () =>
{
logger.LogSomeMessage("logging using windows service to azure tables");
logger.LogSomeMessage("logging using windows service to azure tables 2");
events = AzureTableHelper.PollForEvents(connectionString, AzureTableName, 2);
});
Assert.AreEqual(2, events.Count());
var event1 = events.SingleOrDefault(e => e.Payload.Contains(@"""message"": ""logging using windows service to azure tables"""));
Assert.IsNotNull(event1);
var event2 = events.SingleOrDefault(e => e.Payload.Contains(@"""message"": ""logging using windows service to azure tables 2"""));
Assert.IsNotNull(event2);
}
public async static Task <IActionResult> RunAsync([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var queryDictionary = QueryHelpers.ParseQuery(req.RequestUri.Query);
if (!queryDictionary.TryGetValue("channel_id", out var channelId) || string.IsNullOrWhiteSpace(channelId))
{
return(new BadRequestObjectResult("Lacks of parameter: 'channel_id'"));
}
var storageConnectString =
Environment.GetEnvironmentVariable("AzureStorageConnectionString", EnvironmentVariableTarget.Process);
if (string.IsNullOrWhiteSpace(storageConnectString))
{
throw new Exception(
"Lacks of Environment Variable: 'AzureStorageConnectionString'");
}
var azureTableHelper = new AzureTableHelper <LineMessagingApiConfig>(storageConnectString, "LineMessagingApiConfigs");
var lineConfig = azureTableHelper.Select($"ibo-line-{channelId}", "channel-config");
if (lineConfig == null)
{
return(new BadRequestObjectResult("Invalid 'channel_id'"));
}
var events = await req.GetWebhookEventsAsync(lineConfig.ChannelSecret);
Parallel.ForEach(events.GroupBy(x => x.Type), webhookEventGroup =>
{
LineEventDispatcherFactory.Create(webhookEventGroup.Key).Dispatch(webhookEventGroup.ToList(), lineConfig);
});
return(new OkObjectResult("OK"));
}
public void WhenListenerIsDisposed()
{
this.tableName = "WhenListenerIsDisposed";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With2Listeners(
logger,
(listener1, listener2) =>
{
listener1.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20));
listener2.LogToWindowsAzureTable("mytestinstance2", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(20));
listener1.EnableEvents(logger, EventLevel.LogAlways);
listener2.EnableEvents(logger, EventLevel.LogAlways);
var logTaskList = new List <Task>();
for (int i = 0; i < 105; i++)
{
var messageNumber = i;
logTaskList.Add(Task.Run(() => logger.Critical(messageNumber + "Critical message")));
}
Task.WaitAll(logTaskList.ToArray(), TimeSpan.FromSeconds(10));
listener1.Dispose();
listener2.Dispose();
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 600);
Assert.AreEqual(210, events.Count());
});
}
public void WhenEventWithEnumsInPayloadIsRaised()
{
this.tableName = "WhenEventWithEnumsInPayloadIsRaised";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = MockEventSourceInProcEnum.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: TimeSpan.Zero);
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.SendEnumsEvent17(MockEventSourceInProcEnum.MyColor.Green, MockEventSourceInProcEnum.MyFlags.Flag2);
});
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
Assert.AreEqual((int)MockEventSourceInProcEnum.Tasks.DBQuery, events.ElementAt(0).Task);
Assert.AreEqual((int)EventOpcode.Resume, events.ElementAt(0).Opcode);
StringAssert.Contains(events.ElementAt(0).Payload, @"""a"": 2");
StringAssert.Contains(events.ElementAt(0).Payload, @"""b"": 2");
}
public void WhenBufferIntervalExceedsAndLessEntriesThanBufferCount()
{
this.tableName = "WhenBufferIntervalExceedsAndLessEntriesThanBufferCount";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
var bufferingInterval = TimeSpan.FromSeconds(2);
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval);
listener.EnableEvents(logger, EventLevel.Informational);
// 100 events or more will be flushed by count before the buffering interval elapses
for (int i = 0; i < 90; i++)
{
logger.Informational("Message1");
}
// Wait for buffer interval to elapse and allow time for events to be written
Task.Delay(bufferingInterval.Add(TimeSpan.FromSeconds(5))).Wait();
var events = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(90, events);
});
}
public void WhenUsingExternalConfig()
{
this.tableName = "outProcazuretablesusingconfig";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = MockEventSourceOutProc.Logger;
IEnumerable <WindowsAzureTableEventEntry> events = null;
var svcConfiguration = TraceEventServiceConfiguration.Load("Configurations\\AzureTables\\AzureTables.xml");
using (TraceEventService collector = new TraceEventService(svcConfiguration))
{
try
{
collector.Start();
for (int i = 0; i < 10; i++)
{
logger.Critical("Critical message");
}
events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 10);
}
finally
{
collector.Stop();
}
}
Assert.AreEqual <int>(10, events.Count());
Assert.AreEqual <int>(2, events.First().EventId);
}
public void WhenBufferingWithMinimumNonDefaultInterval()
{
this.tableName = "WhenBufferingWithMinimalNonDefaultInterval";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
// Minimum buffering interval is 500 ms
var minimumBufferingInterval = TimeSpan.FromMilliseconds(500);
listener.LogToWindowsAzureTable("mytestinstance1", connectionString, this.tableName, bufferingInterval: minimumBufferingInterval);
listener.EnableEvents(logger, EventLevel.LogAlways);
var logTaskList = new List <Task>();
for (int i = 0; i < 10; i++)
{
logger.Critical("Critical message");
}
// Wait for the events to be written and assert
Task.Delay(TimeSpan.FromSeconds(3)).Wait();
var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(10, eventsCount);
});
// No more events should be written during the Dispose flush
var eventsCountFinal = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(10, eventsCountFinal);
}
private async void btnLogin_Click(object sender, RoutedEventArgs e)
{
Player player = new Player();
player.Username = txtUsername.Text;
player.Password = passwordBox.Password;
if (!String.IsNullOrEmpty(player.Username) && !String.IsNullOrEmpty(player.Password) && player.Username.Length >= 4 && player.Password.Length >= 6)
{
var res = AzureTableHelper.Validate(player).Result;
if (res)
{
App.CurrentUser = player;
this.Frame.Navigate(typeof(MainPage));
}
else
{
var dialog = new MessageDialog("Oops.......Not a valid username & passworrd ! ! !");
await dialog.ShowAsync();
}
}
else
{
var dialog = new MessageDialog("Enter valid username & password");
await dialog.ShowAsync();
}
}
public void Teardown()
{
if (!string.IsNullOrWhiteSpace(this.tableName))
{
AzureTableHelper.DeleteTable(System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"], this.tableName);
}
}
public void WhenNoPayload()
{
this.tableName = "WhenNoPayload";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
using (var listener = new ObservableEventListener())
{
try
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.EventWithoutPayloadNorMessage();
}
finally
{
listener.DisableEvents(logger);
}
}
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
Assert.AreEqual(TestEventSource.EventWithoutPayloadNorMessageId, events.ElementAt(0).EventId);
}
public void WhenSourceIsEnabledAndDisabled()
{
this.tableName = "WhenSourceIsEnabledAndDisabled";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(1));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.Critical("This is a critical message");
var events = AzureTableHelper.PollForEvents(connectionString, this.tableName, 1);
Assert.AreEqual(1, events.Count());
listener.DisableEvents(logger);
logger.Critical("This is a critical message");
});
var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(1, eventsCount);
}
private async void btnRegister_Click(object sender, RoutedEventArgs e)
{
Player player = new Player();
player.Username = txtUsername.Text;
player.Password = passwordBox.Password;
if (!String.IsNullOrEmpty(player.Username) && !String.IsNullOrEmpty(player.Password) &&
player.Username.Length >= 4 && player.Password.Length >= 6)
{
Task <bool> res = AzureTableHelper.Insert(player);
if (res.Result)
{
App.CurrentUser = player;
this.Frame.Navigate(typeof(MainPage));
}
else
{
var dialog = new MessageDialog("Oops.......Username already taken. Try different name ! ! !");
await dialog.ShowAsync();
}
}
else
{
var dialog = new MessageDialog("Enter valid username & password");
await dialog.ShowAsync();
}
}
private void InitializeTable()
{
if (this.Table == null)
{
this.Table = AzureTableHelper.GetTableReferenceAsync(TableName);
}
}
protected async void Page_Load(object sender, EventArgs e)
{
if (DB == null)
{
DB = new AzureTableHelper("Absen");
}
try
{
string strID = Request.QueryString["IDS"];
//deserialize the object
//Absen objAbsen = Newtonsoft.Json.JsonConvert.DeserializeObject<Absen>(strJson);
if (strID != null)
{
var item = new AbsenData()
{
IDS = strID
};
item.AssignKey();
await DB.InsertDataAbsen(item);
Lit1.Text = (string.Format("Data={0}", strID));
}
else
{
Lit1.Text = ("No Data");
}
}
catch (Exception ex)
{
Lit1.Text = ("Error :" + ex.Message);
}
}
public void WhenInternalBufferCountIsExceededAndIntervalExceeded()
{
this.tableName = "WhenInternalBufferCountIsExceededAndIntervalExceeded";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
var bufferingInterval = TimeSpan.FromSeconds(5);
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: bufferingInterval);
listener.EnableEvents(logger, EventLevel.Informational);
// When reachiing 100 events buffer will be flushed
for (int i = 0; i < 110; i++)
{
logger.Informational("Message1");
}
// Wait for buffer interval to elapse
Task.Delay(bufferingInterval).Wait();
var events = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(100, events);
});
// Last events should be written during the Dispose flush
var eventsCountFinal = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
Assert.AreEqual(110, eventsCountFinal);
}
// PUT api/values/5
public async Task <UserEntity> Put(string id, [FromBody] UserEntity value)
{
if (value == null)
{
return(new UserEntity
{
Username = "******"
});
}
InitializeTable();
UserEntity userEntity = (from machine in this.Table.CreateQuery <UserEntity>()
where machine.PartitionKey == id.First().ToString()
where machine.RowKey == id
select machine).FirstOrDefault();
if (userEntity == null)
{
userEntity = new UserEntity
{
Username = id,
PartitionKey = id.First().ToString(),
RowKey = id,
Timestamp = DateTime.UtcNow,
};
}
await AzureTableHelper.InsertOrMergeEntityAsync(this.Table, userEntity);
return(userEntity);
}
public void WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised()
{
this.tableName = "WhenNotEnabledWithKeywordsAndEventWithSpecificKeywordIsRaised";
var connectionString = System.Configuration.ConfigurationManager.AppSettings["StorageConnectionString"];
AzureTableHelper.DeleteTable(connectionString, this.tableName);
var logger = TestEventSource.Logger;
TestScenario.With1Listener(
logger,
listener =>
{
listener.LogToWindowsAzureTable("mytestinstance", connectionString, this.tableName, bufferingInterval: TimeSpan.FromSeconds(10));
listener.EnableEvents(logger, EventLevel.LogAlways);
logger.ErrorWithKeywordDiagnostic("Error with keyword EventlogClassic");
});
var eventsCount = AzureTableHelper.GetEventsCount(connectionString, this.tableName);
int eventCount = 0;
#if EVENT_SOURCE_PACKAGE
eventCount = 1;
#endif
Assert.AreEqual(eventCount, eventsCount);
}
public EventStoreTests(DependencyInjectionFixture diFixture)
{
var tables = diFixture.Container.GetRequiredService <IDictionary <string, CloudTable> >();
_aggregateId = new CarId(Guid.NewGuid());
_container = diFixture.Container;
_eventStoreTable = tables[ContainerName.EventStore];
_azureTableHelper = new AzureTableHelper <DynamicTableEntity>(4);
}
public RepositoryTests(DependencyInjectionFixture diFixture)
{
var tables = diFixture.Container.GetRequiredService <IDictionary <string, CloudTable> >();
// These variables are reset per unit test
_carId = new CarId(Guid.NewGuid());
_azureTableHelper = new AzureTableHelper <DynamicTableEntity>();
_repository = diFixture.Container.GetRequiredService <IAggregateRepository <Car, CarId> >();
_eventStoreTable = tables[ContainerName.EventStore];
}
public void Test_Constructor()
{
try
{
AzureTableHelper helper = new AzureTableHelper();
}
catch (Exception)
{
Assert.Fail("Constructor failed");
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (tablehelper == null)
{
tablehelper = new AzureTableHelper("cctv");
}
if (!IsPostBack)
{
RefreshGrid();
}
}
