public void CreateBlob_WhenCalledWithBlob_Succeeds()
{
//Arrange
var blobId = Guid.Parse("38C3976B-5AE8-4F2F-A8EC-46F6AEE826E2");
var bytes = Encoding.UTF8.GetBytes("This is a test");
_mockProviderService.UponReceiving("a request to create a new blob")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = String.Format("/blobs/{0}", blobId),
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/octet-stream" }
},
Body = bytes
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 201
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act / Assert
consumer.CreateBlob(blobId, bytes, "test.txt");
_mockProviderService.VerifyInteractions();
}
public void GetBlob_WhenCalledWithId_Succeeds()
{
//Arrange
var blobId = Guid.Parse("38C3976B-5AE8-4F2F-A8EC-46F6AEE826E2");
var bytes = Encoding.UTF8.GetBytes("This is a test");
_mockProviderService.UponReceiving("a request to get a new blob by id")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = String.Format("/blobs/{0}", blobId)
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 201,
Headers = new Dictionary <string, string>
{
{ "Content-Type", "text/plain" }
},
Body = "This is a test"
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act / Assert
var content = consumer.GetBlob(blobId);
Assert.True(bytes.SequenceEqual(content));
_mockProviderService.VerifyInteractions();
}
public void Version_WhenVersionIsCalled_ReturnsVersionNumber()
{
//Arrange
const string version = "1.0.22";
_mockProviderService.UponReceiving("a request to check the api version")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Headers = new Dictionary <string, object> {
{ "Accept", "application/json" }
},
Path = "/version"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = version
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.Version();
//Assert
Assert.Equal(version, result);
_mockProviderService.VerifyInteractions();
}
public void IsAlive_WhenApiIsAlive_ReturnsTrue()
{
//Arrange
_mockProviderService.UponReceiving("A GET request to check the api status")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/stats/status"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Body = "alive"
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.IsAlive();
//Assert
Assert.Equal(true, result);
_mockProviderService.VerifyInteractions();
}
public void IsAlive_WhenApiIsAlive_ReturnsTrue()
{
//Arrange
_mockProviderService.UponReceiving("A GET request to check the api status")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Headers = new Dictionary <string, string> {
{ "Accept", "application/json" }
},
Path = "/stats/status"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
alive = true
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.IsAlive();
//Assert
Assert.Equal(true, result);
_mockProviderService.VerifyInteractions();
}
public void GetAllEvents_WithNoAuthorizationToken_ShouldFail()
{
//Arrange
_mockProviderService.Given("there are events with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'")
.UponReceiving("a request to retrieve all events with no authorization")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events",
Headers = new Dictionary <string, string>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 401,
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
message = "Authorization has been denied for this request."
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act //Assert
Assert.Throws <HttpRequestException>(() => consumer.GetAllEvents());
_mockProviderService.VerifyInteractions();
}
public void GetAllEvents_WhenCalled_ReturnsAllEvents()
{
//Arrange
var testAuthToken = "SomeValidAuthToken";
_mockProviderService.Given("there are events with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'")
.UponReceiving("a request to retrieve all events")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events",
Headers = new Dictionary <string, string>
{
{ "Accept", "application/json" },
{ "Authorization", $"Bearer {testAuthToken}" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new []
{
new
{
eventId = Guid.Parse("45D80D13-D5A2-48D7-8353-CBB4C0EAABF5"),
timestamp = "2014-06-30T01:37:41.0660548",
eventType = "SearchView"
},
new
{
eventId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9"),
timestamp = "2014-06-30T01:37:52.2618864",
eventType = "DetailsView"
},
new
{
eventId = Guid.Parse("3E83A96B-2A0C-49B1-9959-26DF23F83AEB"),
timestamp = "2014-06-30T01:38:00.8518952",
eventType = "SearchView"
}
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri, testAuthToken);
//Act
var events = consumer.GetAllEvents();
//Assert
Assert.NotEmpty(events);
Assert.Equal(3, events.Count());
_mockProviderService.VerifyInteractions();
}
public MessageManager(EventsApiClient eventsApiManager, PersistenceManager persistenceManager)
{
this.eventsApiManager = eventsApiManager;
this.eventsApiManager.EventsApiUploadUnsuccessful += EventsApiManager_EventsApiUnsuccessfulRequest;
this.eventsApiManager.EventsApiUploadFailure += EventsApiManager_EventsApiUploadFailure;
this.persistenceManager = persistenceManager;
this.appInfo = ApplicationInfoBuilder.Build();
this.deviceInfo = DeviceInfoBuilder.Build();
}
public void TestUploadSuccess()
{
EventsApiClient apiManager = new EventsApiClient(ApiKey, ApiSecret);
RequestHeaderSdkMessage message = new RequestHeaderSdkMessage();
message.DeviceInfo = new DeviceInfo();
message.ClientMpId = 123;
message.AppInfo = new AppInfo();
apiManager.EventsApiUploadSuccess += (request, response) => { Assert.IsFalse(response == null); };
apiManager.EventsApiUploadFailure += (request, exception) => { Assert.Fail("Failed:" + exception.Error); };
apiManager.EnqueueMessage(message);
apiManager.DispatchAsync().Wait();
}
public void GetEventById_WhenTheEventExists_ReturnsEvent()
{
//Arrange
var guidRegex = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
var eventId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9");
var eventType = "DetailsView";
var eventTimestamp = DateTime.UtcNow;
_mockProviderService.Given(String.Format("there is an event with id '{0}'", eventId))
.UponReceiving(String.Format("a request to retrieve event with id '{0}'", eventId))
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = Match.Regex($"/events/{eventId}", $"^\\/events\\/{guidRegex}$"),
Headers = new Dictionary <string, object>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" },
{ "Server", Match.Type("RubyServer") }
},
Body = new
{
eventId = Match.Regex(eventId.ToString(), $"^{guidRegex}$"),
eventType = Match.Type(eventType),
timestamp = Match.Regex(eventTimestamp.ToString("o"), "^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[0-1]|0[1-9]|[1-2][0-9])T(2[0-3]|[0-1][0-9]):([0-5][0-9]):([0-5][0-9])(\\.[0-9]+)?(Z|[+-](?:2[0-3]|[0-1][0-9]):[0-5][0-9])?$")
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.GetEventById(eventId);
//Assert
Assert.Equal(eventId, result.EventId);
Assert.Equal(eventType, result.EventType);
Assert.Equal(eventTimestamp, result.Timestamp);
_mockProviderService.VerifyInteractions();
}
public void TestBadApiKey()
{
EventsApiClient apiManager = new EventsApiClient("foo bad key", "foo bad secret");
RequestHeaderSdkMessage message = new RequestHeaderSdkMessage();
message.DeviceInfo = new DeviceInfo();
message.ClientMpId = 123;
message.AppInfo = new AppInfo();
apiManager.EventsApiUploadSuccess += (request, successargs) => { Assert.Fail(); };
apiManager.EventsApiUploadFailure += (request, failureargs) => { Assert.Fail(); };
apiManager.EventsApiUploadUnsuccessful += (request, badrequestargs) => {
Assert.IsNotNull(request);
Assert.AreEqual(400, badrequestargs.HttpStatusCode);
};
apiManager.EnqueueMessage(message);
apiManager.DispatchAsync().Wait();
}
public void GetEventsByType_WhenOneEventWithTheTypeExists_ReturnsEvent()
{
ContextInfo.SetTestContextName(GetType().Name);
//Arrange
const string eventType = "DetailsView";
_mockProviderService.Given(String.Format("there is one event with type '{0}'", eventType))
.UponReceiving(String.Format("a request to retrieve events with type '{0}'", eventType))
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events",
Query = "type=" + eventType,
Headers = new Dictionary <string, string>
{
{ "Accept", "application/json" }
},
Body = null
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new []
{
new
{
eventType = eventType
}
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.GetEventsByType(eventType);
//Assert
Assert.Equal(eventType, result.First().EventType);
_mockProviderService.VerifyInteractions();
}
public async Task GetEventsByType_WhenOneEventWithTheTypeExists_ReturnsEvent()
{
//Arrange
const string eventType = "DetailsView";
_mockProviderService.Given(string.Format("there is one event with type '{0}'", eventType))
.UponReceiving(string.Format("a request to retrieve events with type '{0}'", eventType))
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events",
Query = Match.Regex($"type={eventType}", "^type=(DetailsView|SearchView)$"),
Headers = new Dictionary <string, object>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new []
{
new
{
eventType = eventType
}
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = await consumer.GetEventsByType(eventType);
//Assert
Assert.Equal(eventType, result.First().EventType);
_mockProviderService.VerifyInteractions();
}
public void GetEventById_WhenTheEventExists_ReturnsEvent()
{
ContextInfo.SetTestContextName(GetType().Name);
//Arrange
var eventId = Guid.Parse("83F9262F-28F1-4703-AB1A-8CFD9E8249C9");
_mockProviderService.Given(String.Format("there is an event with id '{0}'", eventId))
.UponReceiving(String.Format("a request to retrieve event with id '{0}'", eventId))
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events/" + eventId,
Headers = new Dictionary <string, string>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
eventId = eventId
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.GetEventById(eventId);
//Assert
Assert.Equal(eventId, result.EventId);
_mockProviderService.VerifyInteractions();
}
private MParticle(Application application, MParticleOptions options)
{
this.Options = options ?? throw new InvalidOperationException("MParticle must be initialized with a non-null MParticleOptions object.");
this.application = application;
this.application.Suspending += Application_Suspending;
this.application.Resuming += Application_Resuming;
this.application.EnteredBackground += Application_EnteredBackground;
this.application.LeavingBackground += Application_LeavingBackground;
this.apiManager = new EventsApiClient(options.ApiKey, options.ApiSecret);
this.apiManager.UploadInterval = TimeSpan.FromSeconds(options.UploadIntervalSeconds);
this.apiManager.UserAgent = UserAgent;
this.apiManager.Logger = options.Logger;
this.persistenceManager = new PersistenceManager(options);
this.persistenceManager.Initialize(Package.Current.Id.Version);
this.messageManager = new MessageManager(apiManager, persistenceManager);
this.messageManager.Enabled = !persistenceManager.IsOptOut;
this.sessionManager = new SessionManager(messageManager, persistenceManager);
this.Identity = new IdentityApi(options.ApiKey, options.ApiSecret, persistenceManager);
this.Identity.Logger = options.Logger;
}
public void CreateEvent_WhenCalledWithEvent_Succeeds()
{
ContextInfo.SetTestContextName(GetType().Name);
//Arrange
var eventId = Guid.Parse("1F587704-2DCC-4313-A233-7B62B4B469DB");
var dateTime = new DateTime(2011, 07, 01, 01, 41, 03);
DateTimeFactory.Now = () => dateTime;
_mockProviderService.UponReceiving("a request to create a new event")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = "/events",
Headers = new Dictionary <string, string>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
eventId,
timestamp = dateTime.ToString("O"),
eventType = "DetailsView"
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 201
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act / Assert
consumer.CreateEvent(eventId);
_mockProviderService.VerifyInteractions();
}
public void GetAllEvents_ShouldWork()
{
//Arrange
_mockProviderService.Given("there is something happening")
.UponReceiving("a request")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/events",
Headers = new Dictionary <string, object>
{
{ "Accept", "application/json" },
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
events = new string[] { "event1", "event2" }
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
var events = consumer.GetAllEvents();
Assert.Equal(2, events.events.Count());
Assert.Equal("event1", events.events.ToList()[0]);
Assert.Equal("event2", events.events.ToList()[1]);
_mockProviderService.VerifyInteractions();
}
public CachedApiService(IMemoryCache cache, EventsApiClient apiClient)
{
this.cache = cache;
this.apiClient = apiClient;
}
public void GetAllCustomersStatus_ReturnsAllCustomersWithStatus()
{
//Arrange
_mockProviderService
.Given("there are Customers with Status ")
.UponReceiving("a request for all Customers with Status ")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/allCustomersStatus",
Headers = new Dictionary <string, object>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new List <Customer>
{
new Customer
{
name = "Arthur Koenig",
address = "Hier und Da 22",
dateOfBirth = new DateTime(1950, 5, 6),
emailAddress = "*****@*****.**",
financialProducts = new List <Product>()
{
new Product()
{
balance = 64.99m,
interestRate = 20m,
name = "Raspberry Pi 4 Model B 4GB",
productCode = "LEIWAND999"
},
new Product()
{
balance = 25.99m,
interestRate = 30m,
name = "RPI4 Case",
productCode = "EHSICHER123"
},
new Product()
{
balance = 413.20m,
interestRate = 10m,
name = "Baum im Wald",
productCode = "UMFALLT222"
},
},
status = "Royal"
},
new Customer
{
name = "Merlin Magyerhofer",
address = "Immer wieder nie 45",
dateOfBirth = new DateTime(1900, 11, 14),
emailAddress = "*****@*****.**",
financialProducts = new List <Product>()
{
new Product()
{
balance = 25.99m,
interestRate = 30m,
name = "RPI4 Case",
productCode = "EHSICHER123"
}
},
status = "Gold"
},
new Customer
{
name = "Harry Potter",
address = "4 Privet Drive, Little Whinging, Surrey",
dateOfBirth = new DateTime(1989, 7, 23),
emailAddress = "*****@*****.**",
financialProducts = new List <Product>(),
status = "Stone of Wisdom"
}
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.AllCustomersStatus();
//Assert
Assert.NotEmpty(result);
Assert.Equal(3, result.Count());
_mockProviderService.VerifyInteractions();
}
public void GetAllCustomersStatus_ReturnsAllCustomersWithStatus()
{
//Arrange
_mockProviderService
.Given("there is a Customer with Name ")
.UponReceiving("a request for Customer with Name and Financial Products ")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/customerSearch",
Headers = new Dictionary <string, object>
{
{ "Accept", "application/json" }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, object>
{
{ "Content-Type", "application/json; charset=utf-8" }
},
Body =
new Customer
{
name = "Arthur Koenig",
address = "Hier und Da 22",
dateOfBirth = new DateTime(1950, 5, 6),
emailAddress = "*****@*****.**",
financialProducts = new List <Product>()
{
new Product()
{
balance = 64.99m,
interestRate = 20m,
name = "Raspberry Pi 4 Model B 4GB",
productCode = "LEIWAND999"
},
new Product()
{
balance = 25.99m,
interestRate = 30m,
name = "RPI4 Case",
productCode = "EHSICHER123"
},
new Product()
{
balance = 413.20m,
interestRate = 10m,
name = "Baum im Wald",
productCode = "UMFALLT222"
},
},
status = "Royal"
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
var consumerName = "Arthur Koenig";
//Act
var result = consumer.CustomerSearch(consumerName);
//Assert
Assert.NotNull(result);
Assert.IsType <Customer>(result);
Assert.Equal(consumerName, result.name);
_mockProviderService.VerifyInteractions();
}
public void UpSince_WhenApiIsAliveAndWeRetrieveUptime_ReturnsUpSinceDate()
{
//Arrange
var upSinceDate = new DateTime(2014, 6, 27, 23, 51, 12, DateTimeKind.Utc);
_mockProviderService.UponReceiving("a request to check the api status")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Headers = new Dictionary <string, string> {
{ "Accept", "application/json" }
},
Path = "/stats/status"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
alive = true,
_links = new
{
uptime = new
{
href = "/stats/uptime"
}
}
}
});
_mockProviderService
.UponReceiving("a request to check the api uptime")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Headers = new Dictionary <string, string> {
{ "Accept", "application/json" }
},
Path = "/stats/uptime"
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary <string, string> {
{ "Content-Type", "application/json; charset=utf-8" }
},
Body = new
{
upSince = upSinceDate
}
});
var consumer = new EventsApiClient(_mockProviderServiceBaseUri);
//Act
var result = consumer.UpSince();
//Assert
Assert.Equal(upSinceDate.ToString("O"), result.Value.ToString("O"));
_mockProviderService.VerifyInteractions();
}
