public async Task Find_WithScript_ShouldHaveScript()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var layout = "Users";
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/layouts/{layout}/_find")
.WithPartialContent("fuzzzerd") // ensure the request contains the expected content
.WithPartialContent("script").WithPartialContent("nos_ran")
.Respond("application/json", DataApiResponses.SuccessfulFind());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(),
FindTestsHelpers.server,
FindTestsHelpers.file,
FindTestsHelpers.user,
FindTestsHelpers.pass);
// act
var response = await fdc.FindAsync(new User()
{
Name = "fuzzzerd"
}, "nos_ran", null, null);
// assert
var responseDataContainsResult = response.Any(r => r.Created == DateTime.Parse("03/29/2018 15:22:09"));
Assert.True(responseDataContainsResult);
}
public async Task FindAsync_WithPortals_ShouldHaveData()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var layout = "the-layout";
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/layouts/{layout}/_find")
.Respond(HttpStatusCode.OK, "application/json", DataApiResponses.SuccessfulFindWithPortal());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(),
FindTestsHelpers.server,
FindTestsHelpers.file,
FindTestsHelpers.user,
FindTestsHelpers.pass);
var toFind = new PortalModel()
{
ES_ONE = ""
};
// act
var response = await fdc.FindAsync(toFind);
// assert
Assert.NotEmpty(response);
Assert.NotEmpty(response.SelectMany(p => p.Actions));
// hard coded from sample data, if changed update here
Assert.Equal(16, response.First().Actions.First().ID);
}
public async Task FindAsync_WithSkipTake_ShouldHave_LimitOffset()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var layout = "Users";
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/layouts/{layout}/_find")
.WithPartialContent("limit") // ensure the request contains the expected content
.WithPartialContent("offset") // ensure the request contains the expected content
.Respond("application/json", DataApiResponses.SuccessfulFind());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(),
FindTestsHelpers.server,
FindTestsHelpers.file,
FindTestsHelpers.user,
FindTestsHelpers.pass);
// act
var response = await fdc.FindAsync(new User()
{
Name = "fuzzzerd"
}, 5, 5);
// assert
Assert.NotEmpty(response);
}
public async Task CreateWithScript_RequiresScriptSet()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records*")
.WithPartialContent("fieldData")
.WithPartialContent("script") // ensure the body contains the script parameter we're sending
.WithPartialContent("run_this_script")
.Respond("application/json", DataApiResponses.SuccessfulCreate());
IFileMakerApiClient fdc = GetDataClientWithMockedHandler(mockHttp);
var req = new CreateRequest <User>()
{
Layout = "layout",
Data = new User {
Name = "test name"
},
Script = "run_this_script"
};
var response = await fdc.SendAsync(req);
Assert.NotNull(response);
Assert.Contains(response.Messages, r => r.Message == "OK");
}
public async Task Edit_WithScript_ShouldHaveScript()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "Users";
var rid = 25;
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(new HttpMethod("PATCH"), $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records/{rid}")
.WithPartialContent("script").WithPartialContent("myscr_name")
.Respond("application/json", DataApiResponses.SuccessfulEdit());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), server, file, user, pass);
var response = await fdc.EditAsync(rid, "myscr_name", null, new User()
{
Name = "test user"
});
Assert.NotNull(response);
Assert.Contains(response.Messages, r => r.Message == "OK");
}
public async Task GetLayout_Should_Return_Layout_Metadata()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var layoutData = System.IO.File.ReadAllText("ResponseData\\SpecificLayout.json");
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/layouts/*")
.Respond("application/json", layoutData);
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
var response = await fdc.GetLayoutAsync(file, "layout");
Assert.NotNull(response);
Assert.Equal("CustomerName", response.FieldMetaData.FirstOrDefault().Name);
// sample data has one value list with two items
Assert.Equal(2, response.ValueLists.First().Values.Count);
}
public async Task GetLayouts_Should_Return_Layout_List()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var layoutData = System.IO.File.ReadAllText("ResponseData\\LayoutList.json");
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/layouts")
.Respond("application/json", layoutData);
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
var response = await fdc.GetLayoutsAsync(file);
Assert.NotNull(response);
Assert.Equal("Customers", response.First().Name);
}
public async Task GetProductInfo_Should_Return_OK()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var productInfo = System.IO.File.ReadAllText("ResponseData\\ProductInfo.json");
mockHttp.When($"{server}/fmi/data/v1/productinfo")
.Respond("application/json", productInfo);
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
var response = await fdc.GetProductInformationAsync();
Assert.NotNull(response);
Assert.NotEmpty(response.Name);
}
public async Task Find_NotFound_Should_ReturnEmpty()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var layout = FileMakerRestClient.GetLayoutName(new User());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/layouts/{layout}/_find")
.Respond(HttpStatusCode.InternalServerError, "application/json", DataApiResponses.FindNotFound());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(),
FindTestsHelpers.server,
FindTestsHelpers.file,
FindTestsHelpers.user,
FindTestsHelpers.pass);
// act
var toFind = new User()
{
Id = 35
};
var response = await fdc.FindAsync(toFind);
// assert
Assert.Empty(response);
}
public async Task EditAsync_Should_Throw_FMDataException_For_InternalServerError()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.Server}/fmi/data/v1/databases/{FindTestsHelpers.File}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(new HttpMethod("PATCH"), $"{s_server}/fmi/data/v1/databases/{s_file}/layouts/{s_layout}/records*")
.WithPartialContent("fieldData")
.Respond(HttpStatusCode.InternalServerError, "application/json", DataApiResponses.FieldNotFound());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), FindTestsHelpers.Connection);
var req = new EditRequest <Dictionary <string, string> >()
{
Layout = s_layout,
RecordId = 264,
Data = new Dictionary <string, string>()
{
{ "Name", "Fuzzerd-Updated" },
{ "AnotherField", "Another-Updated" }
}
};
// act
// assert
await Assert.ThrowsAsync <FMDataException>(async() => await fdc.SendAsync(req));
}
public async Task EditContainer_Should_PostUpload()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "layout";
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records/*")
.WithPartialContent("upload")
.Respond("application/json", DataApiResponses.SuccessfulEdit());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
var b64String = System.IO.File.ReadAllText(Path.Combine("ResponseData", "b64-string.dat"));
var bytes = Convert.FromBase64String(b64String);
var response = await fdc.UpdateContainerAsync(layout, 12, "field", "test.jpg", bytes);
Assert.NotNull(response);
Assert.Contains(response.Messages, r => r.Message == "OK");
}
public async Task UserAgent_Should_Match_Version_Of_Assembly()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var fmrAssembly = System.Reflection.Assembly.GetExecutingAssembly().GetReferencedAssemblies().Single(a => a.Name.StartsWith("FMData.Rest"));
var asm = System.Reflection.Assembly.Load(fmrAssembly.ToString());
var fmrVer = System.Diagnostics.FileVersionInfo.GetVersionInfo(asm.Location).ProductVersion;
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.WithHeaders("User-Agent", $"{fmrAssembly.Name}/{fmrVer}")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Delete, $"{server}/fmi/data/v1/databases/{file}/sessions*")
.Respond(HttpStatusCode.OK, "application/json", "");
using var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo { FmsUri = server, Database = file, Username = user, Password = pass });
await fdc.RefreshTokenAsync(user, pass);
Assert.True(fdc.IsAuthenticated);
}
public async Task GetByRecordId_ShouldReturnMatchingRecordId()
{
// arrange
object FMrecordIdMapper(User o, int id) => o.FileMakerRecordId = id;
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "Users";
var recordId = 26;
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Get, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records/{recordId}")
.Respond("application/json", DataApiResponses.SuccessfulGetById(recordId));
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
// act
var response = await fdc.GetByFileMakerIdAsync <User>(layout, recordId, FMrecordIdMapper);
// assert
Assert.Equal(recordId, response.FileMakerRecordId);
}
public async Task ProcessContainerData_Should_Skip_InvalidUris(string uri)
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
var model = new ContainerFieldTestModel
{
SomeContainerField = uri
};
// act
await fdc.ProcessContainer(model);
// assert
Assert.Null(model.SomeContainerFieldData);
}
public async Task Test_DateTime_To_Timestamp_Parsing()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "Users";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/_find")
.WithPartialContent("fuzzzerd") // ensure the request contains the expected content
.Respond("application/json", DataApiResponses.SuccessfulFind());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), server, file, user, pass);
// act
var response = await fdc.FindAsync(new User()
{
Name = "fuzzzerd"
});
// assert
var responseDataContainsResult = response.Any(r => r.Created == DateTime.Parse("03/29/2018 15:22:09"));
Assert.True(responseDataContainsResult);
}
public async Task SetGlobal_Should_Throw_When_Value_Not_Specified()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(new HttpMethod("PATCH"), $"{s_server}/fmi/data/v1/databases/{s_file}/globals")
.WithPartialContent("globalFields")
.Respond("application/json", DataApiResponses.SetGlobalSuccess());
var fdc = GetDataClientWithMockedHandler(mockHttp);
await Assert.ThrowsAsync <ArgumentNullException>(async() => await fdc.SetGlobalFieldAsync("Table", "Field", null));
}
public async Task SetGlobal_Should_Have_Global_In_Json()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(new HttpMethod("PATCH"), $"{s_server}/fmi/data/v1/databases/{s_file}/globals")
.WithPartialContent("{\"globalFields\":{\"Table::Field\":\"Value\"}}")
.Respond("application/json", DataApiResponses.SetGlobalSuccess());
var fdc = GetDataClientWithMockedHandler(mockHttp);
var globalResponse = await fdc.SetGlobalFieldAsync("Table", "Field", "Value");
Assert.NotNull(globalResponse);
Assert.Contains(globalResponse.Messages, r => r.Message == "OK");
}
private static FileMakerRestClient GenerateClient()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(new HttpMethod("PATCH"), $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records*")
.WithPartialContent("fieldData")
.Respond("application/json", DataApiResponses.SuccessfulEdit());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), server, file, user, pass);
return(fdc);
}
public async Task RefreshToken_Requires_AllParameters(string user, string pass)
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication("someOtherToken"));
mockHttp.When(HttpMethod.Delete, $"{server}/fmi/data/v1/databases/{file}/sessions*")
.Respond(HttpStatusCode.OK, "application/json", "");
// pass in actual values here since we DON'T want this to blow up on constructor
using var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo { FmsUri = server, Database = file, Username = user, Password = pass });
await Assert.ThrowsAsync <ArgumentException>(async() => await fdc.RefreshTokenAsync(user, pass));
}
public async Task SendAsyncFind_WithBadLayout_Throws()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.Server}/fmi/data/v1/databases/{FindTestsHelpers.File}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.Server}/fmi/data/v1/databases/{FindTestsHelpers.File}/layouts/*")
.Respond(HttpStatusCode.InternalServerError, "application/json", DataApiResponses.LayoutNotFound());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), FindTestsHelpers.Connection);
// act
// assert
await Assert.ThrowsAsync <FMDataException>(async() => await fdc.SendAsync(FindTestsHelpers.FindUserReqWithLayoutOverride()));
}
private static FileMakerRestClient GenerateClient()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When($"{s_server}/fmi/data/v1/databases/{s_file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(new HttpMethod("PATCH"), $"{s_server}/fmi/data/v1/databases/{s_file}/layouts/{s_layout}/records*")
.WithPartialContent("fieldData")
.Respond("application/json", DataApiResponses.SuccessfulEdit());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = s_server, Database = s_file, Username = s_user, Password = s_pass
});
return(fdc);
}
public void DataClient_ShouldHandle_401_From_Sessions()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond(HttpStatusCode.Unauthorized, "application/json", DataApiResponses.Authentication401());
mockHttp.When(HttpMethod.Delete, $"{server}/fmi/data/v1/databases/{file}/sessions*")
.Respond(HttpStatusCode.OK, "application/json", "");
using var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo { FmsUri = server, Database = file, Username = user, Password = pass });
Assert.False(fdc.IsAuthenticated);
}
public void DoesNotGetTokenOnConstructor()
{
using var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost/";
var file = "test-file";
var user = "******";
var pass = "******";
// note the lack of slash here vs other tests to ensure the actual auth endpoint is correctly mocked/hit
mockHttp.When($"{server}fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Delete, $"{server}fmi/data/v1/databases/{file}/sessions*")
.Respond(HttpStatusCode.OK, "application/json", "");
using var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo { FmsUri = server, Database = file, Username = user, Password = pass });
Assert.False(fdc.IsAuthenticated);
}
public async Task RefreshToken_ShouldGet_NewToken()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication("someOtherToken"));
mockHttp.When(HttpMethod.Delete, $"{server}/fmi/data/v1/databases/{file}/sessions*")
.Respond(HttpStatusCode.OK, "application/json", "");
using var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo { FmsUri = server, Database = file, Username = user, Password = pass });
var response = await fdc.RefreshTokenAsync("integration", "test");
Assert.Equal("someOtherToken", response.Response.Token);
}
private static IFileMakerApiClient GetDataClientWithMockedHandler(MockHttpMessageHandler mockHttp = null)
{
if (mockHttp == null)
{
// new up a default set of responses (none were provided)
mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records*")
.WithPartialContent("fieldData") // make sure that the body content contains the 'data' object expected by fms
.Respond("application/json", DataApiResponses.SuccessfulCreate());
}
// always add the authentication setup
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), server, file, user, pass);
return(fdc);
}
public static IFileMakerApiClient GetMockedFDC()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Get, $"{server}/fmi/data/v1/databases/{file}/layout*")
.Respond("application/json", DataApiResponses.SuccessfulFind());
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/layout/_find")
.Respond("application/json", DataApiResponses.SuccessfulFind());
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/layouts/Users/_find")
.Respond("application/json", DataApiResponses.SuccessfulFind());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), server, file, user, pass);
return(fdc);
}
private IFileMakerApiClient GetMockedClient()
{
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "layout";
mockHttp.When($"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Delete, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records/*")
.Respond("application/json", DataApiResponses.SuccessfulDelete());
var mockedClient = mockHttp.ToHttpClient();
var fdc = new FileMakerRestClient(mockedClient, server, file, user, pass);
return(fdc);
}
public async Task CreateWithTableAttribute_ShouldReturnOK()
{
var mockHttp = new MockHttpMessageHandler();
// since we know 'ModelWithLayout' uses 'Somelayout' as its layout we need to ensure a response for that endpoint
mockHttp.When(HttpMethod.Post, $"{s_server}/fmi/data/v1/databases/{s_file}/layouts/Somelayout/records*")
.WithPartialContent("fieldData") // make sure that the body content contains the 'data' object expected by fms
.Respond("application/json", DataApiResponses.SuccessfulCreate());
var fdc = GetDataClientWithMockedHandler(mockHttp);
var newModel = new ModelWithLayout()
{
Name = "Fuzzzerd",
AnotherField = "Different Value"
};
var response = await fdc.CreateAsync(newModel);
Assert.NotNull(response);
Assert.Contains(response.Messages, r => r.Message == "OK");
}
public async Task GetByRecordId_ShouldHaveContainerWithContainerDataFor()
{
// arrange
object FMrecordIdMapper(ContainerFieldTestModel o, int id) => o.FileMakerRecordId = id;
var mockHttp = new MockHttpMessageHandler();
var server = "http://localhost";
var file = "test-file";
var user = "******";
var pass = "******";
var layout = "Users";
var recordId = 26;
mockHttp.When(HttpMethod.Post, $"{server}/fmi/data/v1/databases/{file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
var b64String = System.IO.File.ReadAllText("ResponseData\\b64-string.dat");
var bytes = Convert.FromBase64String(b64String);
var b64 = new ByteArrayContent(bytes);
mockHttp.When(HttpMethod.Get, $"{server}/some-data-path")
.Respond(b64);
mockHttp.When(HttpMethod.Get, $"{server}/fmi/data/v1/databases/{file}/layouts/{layout}/records/{recordId}")
.Respond("application/json", DataApiResponses.SuccessfulGetByIdWithContainer(recordId, $"{server}/some-data-path"));
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(), new ConnectionInfo {
FmsUri = server, Database = file, Username = user, Password = pass
});
// act
var response = await fdc.GetByFileMakerIdAsync <ContainerFieldTestModel>(recordId, FMrecordIdMapper);
// assert
Assert.Equal(bytes, response.SomeContainerFieldData);
}
public async Task SendAsyncFind_WithOmit_Omits()
{
// arrange
var mockHttp = new MockHttpMessageHandler();
var layout = "the-layout";
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/sessions")
.Respond("application/json", DataApiResponses.SuccessfulAuthentication());
mockHttp.When(HttpMethod.Post, $"{FindTestsHelpers.server}/fmi/data/v1/databases/{FindTestsHelpers.file}/layouts/*")
.WithPartialContent("omit")
.Respond(HttpStatusCode.OK, "application/json", DataApiResponses.SuccessfulFind());
var fdc = new FileMakerRestClient(mockHttp.ToHttpClient(),
FindTestsHelpers.server,
FindTestsHelpers.file,
FindTestsHelpers.user,
FindTestsHelpers.pass);
var toFind = new User()
{
Id = 35
};
var req = new FindRequest <User>()
{
Layout = layout
};
req.AddQuery(toFind, true);
var response = await fdc.SendAsync(req);
// assert
// since we're not really talking to fms, we know our
// response data has 4, so we know if we had an 'omit'
// in our request and a 4 in our resposne things worked as expected.
Assert.Contains(response, c => c.Id == 4);
}
