NUnitLite provides a place to execute any initialization code that may be required by the tests. In our case, we need to create an instance of our data service, which the test methods will later interact with. The Setup() method is the perfect place since it will be called before each test.

Now the real work begins; we need to create test methods to test each significant scenario. In the case of the data service, we need to be sure of covering the following:

There are many more scenarios we could choose to test, but the preceding small set should help to verify if the basics of our data service are functioning.

[Test]
public void CreatePOI ()
{
  PointOfInterest newPOI = new PointOfInterest ();
  newPOI.Name = "New POI";
  newPOI.Description = "POI to test creating a new POI";
  newPOI.Address = "100 Main Street
Anywhere, TX 75069";
  _poiService.SavePOI (newPOI);

  int testId = newPOI.Id.Value;

  // refresh the cache to be sure the data was 
  // saved appropriately
  _poiService.RefreshCache ();

  // verify if the newly create POI exists
  PointOfInterest poi = _poiService.GetPOI (testId);
  Assert.NotNull (poi);
  Assert.AreEqual (poi.Name, "New POI");
}

[Test]
public void UpdatePOI ()
{
  PointOfInterest testPOI = new PointOfInterest ();
  testPOI.Name = "Update POI";
  testPOI.Description = "POI being saved so we can test update";
  testPOI.Address = "100 Main Street
Anywhere, TX 75069";
  _poiService.SavePOI (testPOI);

  int testId = testPOI.Id.Value;

  // refresh the cache to be sure the data and 
  // poi was saved appropriately
  _poiService.RefreshCache ();

  PointOfInterest poi = _poiService.GetPOI (testId);
  poi.Description = "Updated Description for Update POI";
  _poiService.SavePOI (poi);

  // refresh the cache to be sure the data was 
  // updated appropriately
  _poiService.RefreshCache ();

  PointOfInterest poi = _poiService.GetPOI (testId);
  Assert.NotNull (poi);
  Assert.AreEqual (poi.Description, "Updated Description for Update POI");
}

 [Test]
public void DeletePOI ()
{
  PointOfInterest testPOI = new PointOfInterest ();
  testPOI.Name = "Delete POI";
  testPOI.Description = "POI being saved so we can test delete";
  testPOI.Address = "100 Main Street
Anywhere, TX 75069";
  _poiService.SavePOI (testPOI);

  int testId = testPOI.Id.Value;

  // refresh the cache to be sure the data and 
  // poi was saved appropriately
  _poiService.RefreshCache ();

  PointOfInterest deletePOI = _poiService.GetPOI (testId);
  Assert.IsNotNull (deletePOI);
  _poiService.DeletePOI (deletePOI);

  // refresh the cache to be sure the data was 
  // deleted appropriately
  _poiService.RefreshCache ();

  PointOfInterest poi = _poiService.GetPOI (testId);
  Assert.Null (poi);
}

Now that the tests have been developed, we are ready to execute them. To do this, we simply run the test app using the Android emulator or a physical device.

To execute the tests in an emulator, perform the following steps:

So far, we have created a skeleton of POIJsonService and have a suite of automated tests to test the CRUD methods. It is now time to focus on filling in the logic so that all the tests pass.

To download and add Json.NET to the POIApp project, perform the following steps:

Adding Json.NET to POITestApp is easy because we have already downloaded it; simply select the components package in a project, right-click on it, and select Edit Components, and then select Add to Project, which is next to Json.NET.

We will need a private collection to facilitate the caching of the POIs, and the RefreshCache() method will be used to load the POIs into the collection. Add the following List definition to the POIJsonService class. You will need to use the System.Collections.Generic namespace.

private List<PointOfInterest> _pois = new List<PointOfInterest>();

We need to expose this list as a read-only collection to fulfill the interface requirements of IPOIDataService. The following code shows what is needed:

public IReadOnlyList<PointOfInterest> POIs {
  get { return _pois; }
}

We now need to implement the RefreshCache() method to load the cache when POIJsonService is constructed. Once constructed, the service will maintain the cache each time SavePOI() or DeletePOI() is called. Let's look at how to create a .NET object from a JSON text file using Json.NET:

To load the cache, we need to obtain a directory of all the *.json files and load each POI into the cache. The following listing demonstrates how to accomplish this using the Directory class from System.IO:

public void RefreshCache()
{
  _pois.Clear ();

  string[] filenames = Directory.GetFiles (_storagePath, "*.json");

  foreach (string filename in filenames) {
    string poiString = File.ReadAllText (filename);
    PointOfInterest poi = JsonConvert.DeserializeObject<PointOfInterest> (poiString);
    _pois.Add (poi);
  }
}

SavePOI() will be called to save the new and existing POIs, so it fulfils two of the CRUD functions, create and update. In the case of a new POI, SavePOI() needs to assign a value to Id. As you may recall from earlier in the chapter, we can determine whether a POI is new by checking if it has a null ID.

When assigning a new ID, we will take a very simplistic approach. We will inspect the cache of the POIs to determine the highest Id and increment it by 1 to get the next Id.

Create a private method named GetNextId(), which returns an integer based on the logic previously described. The following code snippet is from the code bundle of this book. You will need to use the System.Linq namespace.

private int GetNextId()
  {
   if (_pois.Count == 0)
    return 1;
   else
    return _pois.Max (p => p.Id.Value) + 1;
  }

We need to create one more supporting method to determine the filename. Create a private method named GetFilename(), which accepts an integer ID and returns a string containing the filename. The following code snippet is from the code bundle of this book:

private string GetFilename(int id)
{
  return Path.Combine(_storagePath,"poi" + id.ToString() + ".json");

}

Note the use of Path.Combine() to build the path. This ensures that the proper delimiter is used to construct the path based on the platform on which the code is being executed.

We will now turn our attention to the main logic in SavePOI(). Let's consider how we take a .NET object and store it in a JSON-formatted text file using Json.NET, essentially just the opposite of what we accomplished in the RefreshCache() method. The process in reverse is just as easy.

Now it is just a matter of putting all of these pieces together in the SavePOI() method. The following code snippet is from the code bundle of this book:

public void SavePOI (PointOfInterest poi)
{
  Boolean newPOI = false;
  if (!poi.Id.HasValue) {
    poi.Id = GetNextId ();
    newPOI = true;
  }

  // serialize POI
  string poiString = JsonConvert.SerializeObject (poi);
  // write new file or overwrite existing file
File.WriteAllText (GetFilename (poi.Id.Value), poiString);

  // update cache if file save was successful
  if (newPOI)
    _pois.Add (poi);
}

Note that we only need to add a POI to the cache when creating a new one and only after successfully writing the file.

GetPOI() is a simple method to implement since we have a cache. We simply need to use the Find method on the _poi list and return the results. You will need to use System.Linq. The following code snippet is from the code bundle of this book:

public PointOfInterest GetPOI (int id)
{
    PointOfInterest poi = _pois.Find (p => p.Id == id);
    return poi;
}

Run POITestApp and execute the tests. The test for CreatePOI() and UpdatePOI() should now be executed successfully.

DeletePOI() is also relatively simple. File.Delete() can be used to delete the file and, when successful, we need to be sure to remove the POI from the cache. The following code is from the code bundle of this book:

public void DeletePOI (PointOfInterest poi)
{
  File.Delete (GetFilename (poi.Id));
  _pois.Remove (poi);
}

Run POITestApp and execute the tests. Everything should run successfully now.