C#/.net>> StarWars>> 返回
项目作者： JacekKosciesza

项目描述 ：
GraphQL 'Star Wars' example using GraphQL for .NET, ASP.NET Core, Entity Framework Core
高级语言： C#
项目地址: git://github.com/JacekKosciesza/StarWars.git
创建时间： 2017-02-12T16:01:26Z
项目社区：https://github.com/JacekKosciesza/StarWars
开源协议：MIT License
下载


GraphQL ‘Star Wars’ example using GraphQL for .NET, ASP.NET Core, Entity Framework Core

Build Status

Examples

Roadmap

  • Basic
    • Simple tutorial (step/screenshot/code)
    • Detailed tutorial (steps explanation)
    • 3-Layers (Api, Core, Data) architecture
    • DDD (Domain Driven Design) hexagonal architecture
    • Dependency Inversion (deafult ASP.NET Core IoC container)
    • GraphQL controller
    • In Memory ‘Droid’ Repository
    • Entity Framework ‘Droid’ Repository
    • Automatic database creation
    • Seed database data
    • EF Migrations
    • GraphiQL
    • Unit Tests
    • Visual Studio 2017 RC upgrade
    • Integration Tests
    • Logs
    • Code Coverage
    • Continous Integration
  • Advanced
    • Full ‘Star Wars’ database (Episodes, Characters, Planets, Humans etc.)
    • Base/generic repository
    • Visual Studio 2017 RTM upgrade
    • Repositories
    • GraphQL queries
    • GraphQL mutations
    • Docker
  • PWA (Progressive Web App)
    • Identity microservice
    • Angular frontend
    • Apollo GraphQL Client for Angular
    • Service Worker
    • IndexedDB
    • …

Tutorials

Basic

  • Create ‘StarWars’ empty solution
    empty-solution

  • Add ‘ASP.NET Core Web Application (.NET Core)’ project named ‘StarWars.Api’
    aspnet-core-web-application

  • Select Web API template
    aspnet-core-web-api

  • Update all NuGet packages
    update-all-nuget-packages

  • Update project.json with correct runtime

    1. "runtimes": {
    2.  "win10-x64": { }
    3. }

  • Install GraphQL NuGet package
    install-graphql-nuget-package

  • Create ‘StarWars.Core’ project
    starwars-core-project

  • Create ‘Droid’ model

    1. namespace StarWars.Core.Models
    2. {
    3.   public class Droid
    4.   {
    5.       public int Id { get; set; }
    6.       public string Name { get; set; }
    7.   }
    8. }

  • Create ‘DroidType’ model
    ```csharp
    using GraphQL.Types;
    using StarWars.Core.Models;

namespace StarWars.Api.Models
{
public class DroidType : ObjectGraphType
{
public DroidType()
{
Field(x => x.Id).Description(“The Id of the Droid.”);
Field(x => x.Name, nullable: true).Description(“The name of the Droid.”);
}
}
}

  2. * Create 'StarWarsQuery' model
  3. ```csharp
  4. using GraphQL.Types;
  5. using StarWars.Core.Models;
  7. namespace StarWars.Api.Models
  8. {
  9.     public class StarWarsQuery : ObjectGraphType
  10.     {
  11.         public StarWarsQuery()
  12.         {
  13.             Field<DroidType>(
  14.               "hero",
  15.               resolve: context => new Droid { Id = 1, Name = "R2-D2" }
  16.             );
  17.         }
  18.     }
  19. }

  • Create ‘GraphQLQuery’ model

    1. namespace StarWars.Api.Models
    2. {
    3.   public class GraphQLQuery
    4.   {
    5.       public string OperationName { get; set; }
    6.       public string NamedQuery { get; set; }
    7.       public string Query { get; set; }
    8.       public string Variables { get; set; }
    9.   }
    10. }

  • Create ‘GraphQLController’
    ```csharp
    using GraphQL;
    using GraphQL.Types;
    using Microsoft.AspNetCore.Mvc;
    using StarWars.Api.Models;
    using System.Threading.Tasks;

namespace StarWars.Api.Controllers
{
[Route(“graphql”)]
public class GraphQLController : Controller
{
[HttpPost]
public async Task Post([FromBody] GraphQLQuery query)
{
var schema = new Schema { Query = new StarWarsQuery() };

  1.         var result = await new DocumentExecuter().ExecuteAsync(_ =>
  2.         {
  3.             _.Schema = schema;
  4.             _.Query = query.Query;
  6.         }).ConfigureAwait(false);
  8.         if (result.Errors?.Count > 0)
  9.         {
  10.             return BadRequest();
  11.         }
  13.         return Ok(result);
  14.     }
  15. }

}

  2. * Test using Postman
  3. ![postman-test-query](https://cloud.githubusercontent.com/assets/8171434/22866705/17985b54-f17b-11e6-848c-6482b45e4934.png)
  5. * Create 'IDroidRepository' interface
  6. ```csharp
  7. using StarWars.Core.Models;
  8. using System.Threading.Tasks;
  10. namespace StarWars.Core.Data
  11. {
  12.     public interface IDroidRepository
  13.     {
  14.         Task<Droid> Get(int id);
  15.     }
  16. }

  • Create ‘StarWars.Data’ project
    starwars-data-project

  • Create in memory ‘DroidRepository’
    ```csharp
    using StarWars.Core.Data;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using StarWars.Core.Models;
    using System.Linq;

namespace StarWars.Data.InMemory
{
public class DroidRepository : IDroidRepository
{
private List _droids = new List {
new Droid { Id = 1, Name = “R2-D2” }
};

  1.     public Task<Droid> Get(int id)
  2.     {
  3.         return Task.FromResult(_droids.FirstOrDefault(droid => droid.Id == id));
  4.     }
  5. }

}

  2. * Use 'IDroidRepository' in StarWarsQuery
  3. ```csharp
  4. using GraphQL.Types;
  5. using StarWars.Core.Data;
  7. namespace StarWars.Api.Models
  8. {
  9.     public class StarWarsQuery : ObjectGraphType
  10.     {
  11.         private IDroidRepository _droidRepository { get; set; }
  13.         public StarWarsQuery(IDroidRepository _droidRepository)
  14.         {
  15.             Field<DroidType>(
  16.               "hero",
  17.               resolve: context => _droidRepository.Get(1)
  18.             );
  19.         }
  20.     }
  21. }

  • Update creation of StarWarsQuery in GraphQLController

    1. // ...
    2. public async Task<IActionResult> Post([FromBody] GraphQLQuery query)
    3. {
    4.   var schema = new Schema { Query = new StarWarsQuery(new DroidRepository()) };
    5. // ...

  • Test using Postman

  • Configure dependency injection in Startup.cs

    1. // ...
    2. public void ConfigureServices(IServiceCollection services)
    3. {
    4.   services.AddMvc();
    6.   services.AddTransient<StarWarsQuery>();
    7.   services.AddTransient<IDroidRepository, DroidRepository>();
    8. }
    9. // ...

  • Use constructor injection of StarWarsQuery in GraphQLController

    1. // ...
    2. public class GraphQLController : Controller
    3. {
    4.   private StarWarsQuery _starWarsQuery { get; set; }
    6.   public GraphQLController(StarWarsQuery starWarsQuery)
    7.   {
    8.       _starWarsQuery = starWarsQuery;
    9.   }
    11.   [HttpPost]
    12.   public async Task<IActionResult> Post([FromBody] GraphQLQuery query)
    13.   {
    14.       var schema = new Schema { Query = _starWarsQuery };
    15. // ...

  • Add Microsoft.EntityFrameworkCore and Microsoft.EntityFrameworkCore.SqlServer Nuget packages to StarWars.Data project
    entity-framework-core-nuget
    entity-framework-sql-server-provider-nuget

  • Create StarWarsContext
    ```csharp
    using Microsoft.EntityFrameworkCore;
    using StarWars.Core.Models;

namespace StarWars.Data.EntityFramework
{
public class StarWarsContext : DbContext
{
public StarWarsContext(DbContextOptions options)
: base(options)
{
Database.EnsureCreated();
}

  1.     public DbSet<Droid> Droids { get; set; }
  2. }

}

  2. * Update 'appsetting.json' with database connection
  3. ```json
  4. {
  5.   "Logging": {
  6.     "IncludeScopes": false,
  7.     "LogLevel": {
  8.       "Default": "Debug",
  9.       "System": "Information",
  10.       "Microsoft": "Information"
  11.     }
  12.   },
  13.   "ConnectionStrings": {
  14.     "StarWarsDatabaseConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=StarWars;Integrated Security=SSPI;integrated security=true;MultipleActiveResultSets=True;"
  15.   }
  16. }
  • Create EF droid repository
    ```csharp
    using StarWars.Core.Data;
    using System.Threading.Tasks;
    using StarWars.Core.Models;
    using Microsoft.EntityFrameworkCore;

namespace StarWars.Data.EntityFramework.Repositories
{
public class DroidRepository : IDroidRepository
{
private StarWarsContext _db { get; set; }

  1.     public DroidRepository(StarWarsContext db)
  2.     {
  3.         _db = db;
  4.     }
  6.     public Task<Droid> Get(int id)
  7.     {
  8.         return _db.Droids.FirstOrDefaultAsync(droid => droid.Id == id);
  9.     }
  10. }

}

  2. * Create seed data as an extension to StarWarsContext
  3. ```csharp
  4. using StarWars.Core.Models;
  5. using System.Linq;
  7. namespace StarWars.Data.EntityFramework.Seed
  8. {
  9.     public static class StarWarsSeedData
  10.     {
  11.         public static void EnsureSeedData(this StarWarsContext db)
  12.         {
  13.             if (!db.Droids.Any())
  14.             {
  15.                 var droid = new Droid
  16.                 {
  17.                     Name = "R2-D2"
  18.                 };
  19.                 db.Droids.Add(droid);
  20.                 db.SaveChanges();
  21.             }
  22.         }
  23.     }
  24. }

  • Configure dependency injection and run data seed in Startup.cs
    ```csharp
    // …
    public void ConfigureServices(IServiceCollection services)
    {
    services.AddMvc();

    services.AddTransient();
    services.AddTransient();
    services.AddDbContext(options => 

    1.   options.UseSqlServer(Configuration["ConnectionStrings:StarWarsDatabaseConnection"])

    );
    }

public void Configure(IApplicationBuilder app, IHostingEnvironment env,
ILoggerFactory loggerFactory, StarWarsContext db)
{
loggerFactory.AddConsole(Configuration.GetSection(“Logging”));
loggerFactory.AddDebug();

  1. app.UseMvc();
  3. db.EnsureSeedData();

}
// …

  1. * Run application and make sure database is created
  2. ![ssms-starwars-database-created](https://cloud.githubusercontent.com/assets/8171434/22923521/1fb046da-f2a2-11e6-8e56-c00661e27318.png)
  4. * Final test using Postman
  5. ![postman-test-query](https://cloud.githubusercontent.com/assets/8171434/22866705/17985b54-f17b-11e6-848c-6482b45e4934.png)
  7. #### Entity Framework Migrations
  9. * Add 'Microsoft.EntityFrameworkCore.Design' NuGet package to 'StarWars.Data' project
  10. ![ef-design-nuget](https://cloud.githubusercontent.com/assets/8171434/22964859/fde4e42a-f35a-11e6-89ad-1b5dfeda4e67.png)
  12. * Add 'Microsoft.EntityFrameworkCore.Tools.DotNet' NuGet package to 'StarWars.Data' project
  13. ![ef-tools-dotnet-nuget](https://cloud.githubusercontent.com/assets/8171434/22964861/ff9afdf4-f35a-11e6-8e42-87ed30009877.png)
  15. * Add tools section in project.json (StarWars.Data)
  16. ```json
  17. "tools": {
  18.     "Microsoft.EntityFrameworkCore.Tools.DotNet": "1.1.0-preview4-final"
  19. }
  • Add official workaround for problems with targeting class library (Modify your class library to be a startup application)
    • Add main entry point
      1. namespace StarWars.Data.EntityFramework.Workaround
      2. {
      3.   // WORKAROUND: https://docs.efproject.net/en/latest/miscellaneous/cli/dotnet.html#targeting-class-library-projects-is-not-supported
      4.   public static class Program
      5.   {
      6.       public static void Main() { }
      7.   }
      8. }
    • Add build option in project.json
      1. "buildOptions": {
      2.   "emitEntryPoint": true
      3. }
  • Run migrations command from the console
    1. dotnet ef migrations add Inital -o .\EntityFramework\Migrations
    dotnet-ef-migrations

GrahpiQL

  • Add NPM configuration file ‘package.json’ to StarWars.Api project
    npm-configuration-file

  • Add GraphiQL dependencies and webpack bundle task

    1. {
    2. "version": "1.0.0",
    3. "name": "starwars-graphiql",
    4. "private": true,
    5. "scripts": {
    6.   "start": "webpack --progress"
    7. },
    8. "dependencies": {
    9.   "graphiql": "^0.7.8",
    10.   "graphql": "^0.7.0",
    11.   "isomorphic-fetch": "^2.1.1",
    12.   "react": "^15.3.1",
    13.   "react-dom": "^15.3.1"
    14. },
    15. "devDependencies": {
    16.   "babel": "^5.6.14",
    17.   "babel-loader": "^5.3.2",
    18.   "css-loader": "^0.24.0",
    19.   "extract-text-webpack-plugin": "^1.0.1",
    20.   "postcss-loader": "^0.10.1",
    21.   "style-loader": "^0.13.1",
    22.   "webpack": "^1.13.0"
    23. }
    24. }

  • Add webpack configuration ‘webpack.config.js’
    ```javascript
    var webpack = require(‘webpack’);
    var ExtractTextPlugin = require(‘extract-text-webpack-plugin’);

var output = ‘./wwwroot’;

module.exports = {
entry: {
‘bundle’: ‘./Scripts/app.js’
},

  1. output: {
  2.     path: output,
  3.     filename: '[name].js'
  4. },
  6. resolve: {
  7.     extensions: ['', '.js', '.json']
  8. },
  10. module: {
  11.     loaders: [
  12.       { test: /\.js/, loader: 'babel', exclude: /node_modules/ },
  13.       { test: /\.css$/, loader: ExtractTextPlugin.extract('style-loader', 'css-loader!postcss-loader') }
  14.     ]
  15. },
  17. plugins: [
  18.   new ExtractTextPlugin('style.css', { allChunks: true })
  19. ]

};

  2. * Install 'NPM Task Runner' extension
  3. ![npm-task-runner](https://cloud.githubusercontent.com/assets/8171434/22973925/2a6cd7ee-f380-11e6-89b8-b27fe68a6d1b.png)
  5. * Configure 'After Build' step in 'Task Runner Explorer'
  6. ![after-build-task-runner-explorer](https://cloud.githubusercontent.com/assets/8171434/22974769/25727768-f384-11e6-96ca-8670b67b805c.png)
  7. ```json
  8.   "-vs-binding": { "AfterBuild": [ "start" ] }

  • Add ‘Get’ action to GraphQL controller and GraphiQL view (~/Views/GraphQL/index.cshtml)

    1. // ...
    2. public class GraphQLController : Controller
    3. {
    4.   // ...
    5.   [HttpGet]
    6.   public IActionResult Index()
    7.   {
    8.       return View();
    9.   }    
    10. // ...
    11. }
    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4.   <meta charset="utf-8" />
    5.   <meta name="viewport" content="width=device-width" />
    6.   <title>GraphiQL</title>
    7.   <link rel="stylesheet" href="~/style.css" />
    8. </head>
    9. <body>
    10.   <div id="app"></div>
    11.   <script src="~/bundle.js" type="text/javascript"></script>
    12. </body>
    13. </html>

  • Add GraphiQL scripts and styles (app.js and app.css to ~/GraphiQL)

    • app.js

      1. import React from 'react';
      2. import ReactDOM from 'react-dom';
      3. import GraphiQL from 'graphiql';
      4. import fetch from 'isomorphic-fetch';
      5. import 'graphiql/graphiql.css';
      6. import './app.css';
      8. function graphQLFetcher(graphQLParams) {
      9.   return fetch(window.location.origin + '/graphql', {
      10.       method: 'post',
      11.       headers: { 'Content-Type': 'application/json' },
      12.       body: JSON.stringify(graphQLParams)
      13.   }).then(response => response.json());
      14. }
      16. ReactDOM.render(<GraphiQL fetcher={graphQLFetcher}></GraphiQL>, document.getElementById('app'));

    • app.css

      1. html, body {
      2.   height: 100%;
      3.   margin: 0;
      4.   overflow: hidden;
      5.   width: 100%;
      6. }
      8. #app {
      9.   height: 100vh;
      10. }

  • Add static files support

    • Add ‘Microsoft.AspNetCore.StaticFiles’ NuGet
      static-files-nuget

    • Update configuration in ‘Startup.cs’

      1. // ...
      2. public void Configure(IApplicationBuilder app, IHostingEnvironment env,
      3.                         ILoggerFactory loggerFactory, StarWarsContext db)
      4. {
      5.   loggerFactory.AddConsole(Configuration.GetSection("Logging"));
      6.   loggerFactory.AddDebug();
      8.   app.UseStaticFiles();
      9.   app.UseMvc();
      11.   db.EnsureSeedData();
      12. }
      13. // ...

  • Build project and check if bundles were created by webpack under ~/wwwroot
    bundles-created-by-webpack

  • Run project and enjoy GraphiQL
    graphiql

Unit Tests

  • Create ‘Class Library (.NET Core)’ type ‘StarWars.Tests.Unit’ project
    unit-tests-project

  • Install ‘xunit’ NuGet package in StarWars.Tests.Unit project
    xunit-nuget

  • Install ‘dotnet-test-xunit’ NuGet package in StarWars.Tests.Unit project
    dotnet-test-xunit-nuget

  • Make changes to project.json

    • Set ‘testRunner’
    • Reference ‘StarWars.Data’ project
    • Set ‘runtimes’
      ```json
      {
      “version”: “1.0.0-*”,
      “testRunner”: “xunit”,
      “dependencies”: {
      “dotnet-test-xunit”: “2.2.0-preview2-build1029”,
      “Microsoft.NETCore.App”: “1.1.0”,
      “xunit”: “2.1.0”,
      “StarWars.Data”: {
      “target”: “project”
      }
      },

    “frameworks”: {
    “netcoreapp1.1”: {

    1. "imports": [
    2.   "dotnet5.6",
    3.   "portable-net45+win8"
    4. ]

    }
    },

    “runtimes”: {
    “win10-x64”: {}
    }
    }
    ```

  • Create first test for in memory droid repository
    ```csharp
    using StarWars.Data.InMemory;
    using Xunit;

namespace StarWars.Tests.Unit.Data.InMemory
{
public class DroidRepositoryShould
{
private readonly DroidRepository _droidRepository;
public DroidRepositoryShould()
{
// Given
_droidRepository = new DroidRepository();
}

  1.     [Fact]
  2.     public async void ReturnR2D2DroidGivenIdOf1()
  3.     {
  4.         // When
  5.         var droid = await _droidRepository.Get(1);
  7.         // Then
  8.         Assert.NotNull(droid);
  9.         Assert.Equal("WRONG_NAME", droid.Name);
  10.     }
  11. }

}

  2. * Build and make sure that test is discovered by 'Test Explorer'
  3. ![test-explorer-first-unit-test](https://cloud.githubusercontent.com/assets/8171434/23020737/c1b268ee-f448-11e6-96de-80928174a335.png)
  5. * Run test - it should fail (we want to make sure that we are testing the right thing)
  6. ![first-unit-test-fail](https://cloud.githubusercontent.com/assets/8171434/23022083/56733e6c-f44f-11e6-8f64-84e9da06d879.png)
  8. * Fix test
  9. ```csharp
  10. // ...
  11. [Fact]
  12. public async void ReturnR2D2DroidGivenIdOf1()
  13. {
  14.     // When
  15.     var droid = await _droidRepository.Get(1);
  17.     // Then
  18.     Assert.NotNull(droid);
  19.     Assert.Equal("R2-D2", droid.Name);
  20. }
  21. // ...

  • Run test again - it should pass
    first-unit-test-pass

  • Install ‘Moq’ NuGet package
    moq-nuget

  • Install ‘Microsoft.EntityFrameworkCore.InMemory’ NuGet package
    ef-in-memory-nuget

  • Add reference to ‘StarWars.Core’ in project.json

    1. {
    2. "dependencies": {
    3.   "StarWars.Core": {
    4.     "target": "project"
    5.   }
    6. }
    7. }

  • Create EF droid repository unit test
    ```csharp
    using Microsoft.EntityFrameworkCore;
    using StarWars.Core.Models;
    using StarWars.Data.EntityFramework;
    using StarWars.Data.EntityFramework.Repositories;
    using Xunit;

namespace StarWars.Tests.Unit.Data.EntityFramework.Repositories
{
public class DroidRepositoryShould
{
private readonly DroidRepository _droidRepository;
public DroidRepositoryShould()
{
// Given
// https://docs.microsoft.com/en-us/ef/core/miscellaneous/testing/in-memory
var options = new DbContextOptionsBuilder()
.UseInMemoryDatabase(databaseName: “StarWars”)
.Options;
using (var context = new StarWarsContext(options))
{
context.Droids.Add(new Droid { Id = 1, Name = “R2-D2” });
context.SaveChanges();
}
var starWarsContext = new StarWarsContext(options);
_droidRepository = new DroidRepository(starWarsContext);
}

  1.     [Fact]
  2.     public async void ReturnR2D2DroidGivenIdOf1()
  3.     {
  4.         // When
  5.         var droid = await _droidRepository.Get(1);
  7.         // Then
  8.         Assert.NotNull(droid);
  9.         Assert.Equal("R2-D2", droid.Name);
  10.     }
  11. }

}

  2. * Create GraphQLController unit test
  3.     * First refactor controller to be more testable by using constructor injection
  4.     ```csharp
  5.     using GraphQL;
  6.     using GraphQL.Types;
  7.     using Microsoft.AspNetCore.Mvc;
  8.     using StarWars.Api.Models;
  9.     using System.Threading.Tasks;
  11.     namespace StarWars.Api.Controllers
  12.     {
  13.         [Route("graphql")]
  14.         public class GraphQLController : Controller
  15.         {
  16.             private IDocumentExecuter _documentExecuter { get; set; }
  17.             private ISchema _schema { get; set; }
  19.             public GraphQLController(IDocumentExecuter documentExecuter, ISchema schema)
  20.             {
  21.                 _documentExecuter = documentExecuter;
  22.                 _schema = schema;
  23.             }
  25.             [HttpGet]
  26.             public IActionResult Index()
  27.             {
  28.                 return View();
  29.             }
  31.             [HttpPost]
  32.             public async Task<IActionResult> Post([FromBody] GraphQLQuery query)
  33.             {
  34.                 var executionOptions = new ExecutionOptions { Schema = _schema, Query = query.Query };
  35.                 var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
  37.                 if (result.Errors?.Count > 0)
  38.                 {
  39.                     return BadRequest(result.Errors);
  40.                 }
  42.                 return Ok(result);
  43.             }
  44.         }
  45.     }
  1. * Configure dependency injection in 'Startup.cs'
  2. ```csharp
  3. // ...
  4. public void ConfigureServices(IServiceCollection services)
  5. {
  6.     // ...        
  7.     services.AddTransient<IDocumentExecuter, DocumentExecuter>();
  8.     var sp = services.BuildServiceProvider();
  9.     services.AddTransient<ISchema>(_ => new Schema { Query = sp.GetService<StarWarsQuery>() });
  10. }
  11. // ...
  12. ```
  13. * Create test for 'Index' and 'Post' actions
  14. ```csharp
  15. using GraphQL;
  16. using GraphQL.Types;
  17. using Microsoft.AspNetCore.Mvc;
  18. using Moq;
  19. using StarWars.Api.Controllers;
  20. using StarWars.Api.Models;
  21. using System.Threading.Tasks;
  22. using Xunit;
  24. namespace StarWars.Tests.Unit.Api.Controllers
  25. {
  26.     public class GraphQLControllerShould
  27.     {
  28.         private GraphQLController _graphqlController { get; set; }
  30.         public GraphQLControllerShould()
  31.         {
  32.             // Given
  33.             var documentExecutor = new Mock<IDocumentExecuter>();
  34.             documentExecutor.Setup(x => x.ExecuteAsync(It.IsAny<ExecutionOptions>())).Returns(Task.FromResult(new ExecutionResult()));
  35.             var schema = new Mock<ISchema>();
  36.             _graphqlController = new GraphQLController(documentExecutor.Object, schema.Object);
  37.         }
  39.         [Fact]
  40.         public void ReturnNotNullViewResult()
  41.         {
  42.             // When
  43.             var result = _graphqlController.Index() as ViewResult;
  45.             // Then
  46.             Assert.NotNull(result);
  47.             Assert.IsType<ViewResult>(result);
  48.         }
  50.         [Fact]
  51.         public async void ReturnNotNullExecutionResult()
  52.         {
  53.             // Given
  54.             var query = new GraphQLQuery { Query = @"{ ""query"": ""query { hero { id name } }""" };
  56.             // When
  57.             var result = await _graphqlController.Post(query);
  59.             // Then
  60.             Assert.NotNull(result);
  61.             var okObjectResult =  Assert.IsType<OkObjectResult>(result);
  62.             var executionResult = okObjectResult.Value;
  63.             Assert.NotNull(executionResult);
  64.         }
  65.     }
  66. }
  67. ```

Visual Studio 2017 RC upgrade

  • Open solution in VS 2017 and let the upgrade tool do the job
    vs-2017-rc-upgrade

  • Upgrade of ‘StarWars.Tests.Unit’ failed, so I had to remove all project dependencies and reload it

    1. {
    2. "dependencies": {
    3.   // remove this:
    4.   "StarWars.Data": {
    5.     "target": "project"
    6.   },
    7.   "StarWars.Core": {
    8.     "target": "project"
    9.   }
    10.   // ...
    11. }
    12. }

  • Replace old test txplorer runner for the xUnit.net framework (dotnet-test-xunit) with new one (xunit.runner.visualstudio)
    xunit-runner-visualstudio-nuget

  • Install (xunit.runner.visualstudio) dependency (Microsoft.DotNet.InternalAbstractions)
    microsoft-dotnet-internal-abstractions-nuget

Integration Tests

  • Create ‘xUnit Test Project (.NET Core)’ type ‘StarWars.Tests.Integration’ project
    integration-tests-project

  • Change target framework from ‘netcoreapp1.0’ to ‘netcoreapp1.1’

    1. <Project Sdk="Microsoft.NET.Sdk">
    2. <PropertyGroup>    
    3.   <TargetFramework>netcoreapp1.1</TargetFramework>
    4. </PropertyGroup>
    5. <!--...-->
    6. </Project>

  • Install ‘Microsoft.AspNetCore.TestHost’ NuGet package
    test-host-nuget

  • Use EF in memory database for ‘Test’ evironment

    • Install ‘Microsoft.EntityFrameworkCore.InMemory’ NuGet package
      ef-in-memory-nuget-api-project

    • Configure it in ‘Startup.cs’

      1. // ...
      2. private IHostingEnvironment Env { get; set; }
      4. public class Startup
      5. {
      6.   // ...
      7.   Env = env;
      8. }
      10. public void ConfigureServices(IServiceCollection services)
      11. {
      12.   // ...
      13.   if (Env.IsEnvironment("Test"))
      14.   {
      15.       services.AddDbContext<StarWarsContext>(options =>
      16.           options.UseInMemoryDatabase(databaseName: "StarWars"));
      17.   }
      18.   else
      19.   {
      20.       services.AddDbContext<StarWarsContext>(options =>
      21.           options.UseSqlServer(Configuration["ConnectionStrings:StarWarsDatabaseConnection"]));
      22.   }
      23.   // ...
      24. }
      25. // ...
  • Create integration test for GraphQL query (POST)
    ```csharp
    using Microsoft.AspNetCore.Hosting;
    using Microsoft.AspNetCore.TestHost;
    using StarWars.Api;
    using System.Net.Http;
    using System.Text;
    using Xunit;

namespace StarWars.Tests.Integration.Api.Controllers
{
public class GraphQLControllerShould
{
private readonly TestServer _server;
private readonly HttpClient _client;

  1.     public GraphQLControllerShould()
  2.     {
  3.         _server = new TestServer(new WebHostBuilder()
  4.             .UseEnvironment("Test")
  5.             .UseStartup<Startup>()
  6.         );
  7.         _client = _server.CreateClient();
  8.     }
  10.     [Fact]
  11.     public async void ReturnR2D2Droid()
  12.     {
  13.         // Given
  14.         var query = @"{
  15.             ""query"": ""query { hero { id name } }""
  16.         }";
  17.         var content = new StringContent(query, Encoding.UTF8, "application/json");
  19.         // When
  20.         var response = await _client.PostAsync("/graphql", content);
  22.         // Then
  23.         response.EnsureSuccessStatusCode();
  24.         var responseString = await response.Content.ReadAsStringAsync();
  25.         Assert.Contains("R2-D2", responseString);
  26.     }
  27. }

}

  1. #### Logs
  3. * Make sure that logger is configured in Startup.cs
  4. ```csharp
  5. public void Configure(IApplicationBuilder app, IHostingEnvironment env,
  6.                               ILoggerFactory loggerFactory, StarWarsContext db)
  7. {
  8.     loggerFactory.AddConsole(Configuration.GetSection("Logging"));
  9.     loggerFactory.AddDebug();
  10.     // ...
  11. }

  • Override ToString method of GraphQLQuery class

    1. public override string ToString()
    2. {
    3.   var builder = new StringBuilder();
    4.   builder.AppendLine();
    5.   if (!string.IsNullOrWhiteSpace(OperationName))
    6.   {
    7.       builder.AppendLine($"OperationName = {OperationName}");
    8.   }
    9.   if (!string.IsNullOrWhiteSpace(NamedQuery))
    10.   {
    11.       builder.AppendLine($"NamedQuery = {NamedQuery}");
    12.   }
    13.   if (!string.IsNullOrWhiteSpace(Query))
    14.   {
    15.       builder.AppendLine($"Query = {Query}");
    16.   }
    17.   if (!string.IsNullOrWhiteSpace(Variables))
    18.   {
    19.       builder.AppendLine($"Variables = {Variables}");
    20.   }
    22.   return builder.ToString();
    23. }

  • Add logger to GraphQLController

    1. public class GraphQLController : Controller
    2. {
    3.   // ...
    4.   private readonly ILogger _logger;
    6.   public GraphQLController(IDocumentExecuter documentExecuter, ISchema schema, ILogger<GraphQLController> logger)
    7.   {
    8.       // ...
    9.       _logger = logger;
    10.   }
    12.   [HttpGet]
    13.   public IActionResult Index()
    14.   {
    15.       _logger.LogInformation("Got request for GraphiQL. Sending GUI back");
    16.       return View();
    17.   }
    19.   [HttpPost]
    20.   public async Task<IActionResult> Post([FromBody] GraphQLQuery query)
    21.   {
    22.       // ...
    23.       if (result.Errors?.Count > 0)
    24.       {
    25.           _logger.LogError("GraphQL errors: {0}", result.Errors);
    26.           return BadRequest(result);
    27.       }
    29.       _logger.LogDebug("GraphQL execution result: {result}", JsonConvert.SerializeObject(result.Data));
    30.       return Ok(result);
    31.   }
    32. }

  • Add logger to DroidRepository

    1. namespace StarWars.Data.EntityFramework.Repositories
    2. {
    3.   public class DroidRepository : IDroidRepository
    4.   {
    5.       private StarWarsContext _db { get; set; }
    6.       private readonly ILogger _logger;
    8.       public DroidRepository(StarWarsContext db, ILogger<DroidRepository> logger)
    9.       {
    10.           _db = db;
    11.           _logger = logger;
    12.       }
    14.       public Task<Droid> Get(int id)
    15.       {
    16.           _logger.LogInformation("Get droid with id = {id}", id);
    17.           return _db.Droids.FirstOrDefaultAsync(droid => droid.Id == id);
    18.       }
    19.   }
    20. }

  • Add logger to StarWarsContext

    1. namespace StarWars.Data.EntityFramework
    2. {
    3.   public class StarWarsContext : DbContext
    4.   {
    5.       public readonly ILogger _logger;
    7.       public StarWarsContext(DbContextOptions options, ILogger<StarWarsContext> logger)
    8.           : base(options)
    9.       {
    10.           _logger = logger;
    11.           // ...
    12.       }
    13.   }
    14. }

  • Add logger to StarWarsSeedData

    1. namespace StarWars.Data.EntityFramework.Seed
    2. {
    3.   public static class StarWarsSeedData
    4.   {
    5.       public static void EnsureSeedData(this StarWarsContext db)
    6.       {
    7.           db._logger.LogInformation("Seeding database");
    8.           if (!db.Droids.Any())
    9.           {
    10.               db._logger.LogInformation("Seeding droids");
    11.               // ...
    12.           }
    13.       }
    14.   }
    15. }

  • Fix controller unit test

    1. public class GraphQLControllerShould
    2. {
    3.   public GraphQLControllerShould()
    4.   {
    5.       // ...
    6.       var logger = new Mock<ILogger<GraphQLController>>();
    7.       _graphqlController = new GraphQLController(documentExecutor.Object, schema.Object, logger.Object);
    8.   }
    9.   // ...
    10. }

  • Fix repository unit test
    ```csharp
    using Microsoft.EntityFrameworkCore;
    using Microsoft.Extensions.Logging;
    using Moq;
    using StarWars.Core.Models;
    using StarWars.Data.EntityFramework;
    using StarWars.Data.EntityFramework.Repositories;
    using Xunit;

namespace StarWars.Tests.Unit.Data.EntityFramework.Repositories
{
public class DroidRepositoryShould
{
public DroidRepositoryShould()
{
var dbLogger = new Mock>();
// …
using (var context = new StarWarsContext(options, dbLogger.Object))
{
// …
}
// …
var repoLogger = new Mock>();
_droidRepository = new DroidRepository(starWarsContext, repoLogger.Object);
}
}
}

  2. * Enjoy console logs
  3. ![console-logs-1](https://cloud.githubusercontent.com/assets/8171434/23155559/6b17afe8-f813-11e6-88e0-2923270f4ee8.png)
  4. ![console-logs-2](https://cloud.githubusercontent.com/assets/8171434/23155802/68f8e604-f814-11e6-90a7-44d09e851a51.png)
  6. #### Code Coverage
  8. * Install OpenCover NuGet package
  9. ![open-cover-nuget](https://cloud.githubusercontent.com/assets/8171434/23206746/247aa694-f8ef-11e6-9b14-d0ade0453b94.png)
  11. * Add path to OpenCover tools to 'Path' environment variable. In my case it was:

C:\Users\Jacek_Kosciesza.nuget\packages\opencover\4.6.519\tools\

  2. * Set 'Full' debug type in all projects (StarWars.Api.csproj, StarWars.Core.csproj, StarWars.Data.csproj). This is needed to produce *.pdb files which are understandable by OpenCover.
  3. ```xml
  4. <Project Sdk="Microsoft.NET.Sdk.Web">
  5.   <PropertyGroup>
  6.     <!--...-->
  7.     <DebugType>Full</DebugType>
  8.   </PropertyGroup>
  9.   <!--...-->
  10. </Project>

  • Run OpenCover in the console

    1. OpenCover.Console.exe
    2.   -target:"dotnet.exe"
    3.   -targetargs:"test -f netcoreapp1.1 -c Release Tests/StarWars.Tests.Unit/StarWars.Tests.Unit.csproj"
    4.   -hideskipped:File
    5.   -output:coverage/unit/coverage.xml
    6.   -oldStyle
    7.   -filter:"+[StarWars*]* -[StarWars.Tests*]* -[StarWars.Api]*Program -[StarWars.Api]*Startup -[StarWars.Data]*EntityFramework.Workaround.Program -[StarWars.Data]*EntityFramework.Migrations* -[StarWars.Data]*EntityFramework.Seed*"
    8.   -searchdirs:"Tests/StarWars.Tests.Unit/bin/Release/netcoreapp1.1"
    9.   -register:user

    open-cover-unit-tests-results

  • Install ‘ReportGenerator’ NuGet package
    report-generator-nuget

  • Create simple script (unit-tests.bat)

    1. mkdir coverage\unit
    2. OpenCover.Console.exe -target:"dotnet.exe" -targetargs:"test -f netcoreapp1.1 -c Release Tests/StarWars.Tests.Unit/StarWars.Tests.Unit.csproj" -hideskipped:File -output:coverage/unit/coverage.xml -oldStyle -filter:"+[StarWars*]* -[StarWars.Tests*]* -[StarWars.Api]*Program -[StarWars.Api]*Startup -[StarWars.Data]*EntityFramework.Workaround.Program -[StarWars.Data]*EntityFramework.Migrations* -[StarWars.Data]*EntityFramework.Seed*" -searchdirs:"Tests/StarWars.Tests.Unit/bin/Release/netcoreapp1.1" -register:user
    3. ReportGenerator.exe -reports:coverage/unit/coverage.xml -targetdir:coverage/unit -verbosity:Error
    4. start .\coverage\unit\index.htm

  • Enjoy HTML based code coverage report
    open-cover-html-report-results

    Continous Integration

  • Create new project in VSTS (Visual Studio Team Services)
    vsts-new-project

  • Create new build definition “ASP.NET Core Preview”. Select GitHub, Hosted VS2017 default agent queue and continous integration. At the moment hosted agents don’t support *.csproj based .NET Core projects, so we have to wait for a while, see this issue: Support for .NET Core .csproj files? #3311
    vsts-new-build-definition
    vsts-new-build-definition-github-hosted-vs2017

  • Add new GitHub service connection
    vsts-new-github-service-connection

  • Setup repository
    vsts-setup-repository

  • Switch to “New Build Editor”
    vsts-new-build-editor

  • Setup build process (tasks, build steps)
    vsts-setup-build-steps

  • Setup projects in Test build step

    1. **/Tests/StarWars.Tests.Unit/StarWars.Tests.Unit.csproj;**/Tests/StarWars.Tests.Integration/StarWars.Tests.Integration.csproj

    vsts-setup-projects-test-build-setp

    • Queue build. Make sure it succeeded and executed unit and integration tests.
      vsts-queue-build
      vsts-build-succeeded

  • Enable build badge (after save you will see link to build status image).
    vsts-enable-badge

Advanced

Full ‘Star Wars’ database (see Facebook GraphQL and GraphQL.js)

  • Create models

    1. namespace StarWars.Core.Models
    2. {
    3.   public class Episode
    4.   {
    5.       public int  Id  { get; set; }
    6.       public string Title { get; set; }
    7.       public virtual ICollection<CharacterEpisode> CharacterEpisodes { get; set; }
    8.   }
    9. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Planet
    4.   {
    5.       public int Id { get; set; }
    6.       public string Name { get; set; }
    7.       public ICollection<Human> Humans { get; set; }
    8.   }
    9. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Character
    4.   {
    5.       public int Id { get; set; }
    6.       public string Name { get; set; }
    7.       public virtual ICollection<CharacterEpisode> CharacterEpisodes { get; set; }
    8.       public virtual ICollection<CharacterFriend> CharacterFriends { get; set; }
    9.       public virtual ICollection<CharacterFriend> FriendCharacters { get; set; }
    10.   }
    11. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class CharacterEpisode
    4.   {
    5.       public int CharacterId { get; set; }
    6.       public Character Character { get; set; }
    8.       public int EpisodeId { get; set; }
    9.       public Episode Episode { get; set; }
    10.   }
    11. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class CharacterFriend
    4.   {
    5.       public int CharacterId { get; set; }
    6.       public Character Character { get; set; }
    8.       public int FriendId { get; set; }
    9.       public Character Friend { get; set; }
    10.   }
    11. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Droid : Character
    4.   {
    5.       public string PrimaryFunction { get; set; }
    6.   }
    7. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Human : Character
    4.   {
    5.       public Planet HomePlanet { get; set; }
    6.   }
    7. }

  • Update StarWarsContext

    1. namespace StarWars.Data.EntityFramework
    2. {
    3.   public class StarWarsContext : DbContext
    4.   {
    5.       // ...
    6.       protected override void OnModelCreating(ModelBuilder modelBuilder)
    7.       {
    8.           // https://docs.microsoft.com/en-us/ef/core/modeling/relationships
    9.           // http://stackoverflow.com/questions/38520695/multiple-relationships-to-the-same-table-in-ef7core
    11.           // episodes
    12.           modelBuilder.Entity<Episode>().HasKey(c => c.Id);
    13.           modelBuilder.Entity<Episode>().Property(e => e.Id).ValueGeneratedNever();
    15.           // planets
    16.           modelBuilder.Entity<Planet>().HasKey(c => c.Id);
    17.           modelBuilder.Entity<Planet>().Property(e => e.Id).ValueGeneratedNever();
    19.           // characters
    20.           modelBuilder.Entity<Character>().HasKey(c => c.Id);
    21.           modelBuilder.Entity<Character>().Property(e => e.Id).ValueGeneratedNever();
    23.           // characters-friends
    24.           modelBuilder.Entity<CharacterFriend>().HasKey(t => new { t.CharacterId, t.FriendId});
    26.           modelBuilder.Entity<CharacterFriend>()
    27.               .HasOne(cf => cf.Character)
    28.               .WithMany(c => c.CharacterFriends)
    29.               .HasForeignKey(cf => cf.CharacterId)                
    30.               .OnDelete(DeleteBehavior.Restrict);               
    32.           modelBuilder.Entity<CharacterFriend>()
    33.               .HasOne(cf => cf.Friend)
    34.               .WithMany(t => t.FriendCharacters)
    35.               .HasForeignKey(cf => cf.FriendId)
    36.               .OnDelete(DeleteBehavior.Restrict);
    38.           // characters-episodes
    39.           modelBuilder.Entity<CharacterEpisode>().HasKey(t => new { t.CharacterId, t.EpisodeId });
    41.           modelBuilder.Entity<CharacterEpisode>()
    42.               .HasOne(cf => cf.Character)
    43.               .WithMany(c => c.CharacterEpisodes)
    44.               .HasForeignKey(cf => cf.CharacterId)
    45.               .OnDelete(DeleteBehavior.Restrict);
    47.           modelBuilder.Entity<CharacterEpisode>()
    48.               .HasOne(cf => cf.Episode)
    49.               .WithMany(t => t.CharacterEpisodes)
    50.               .HasForeignKey(cf => cf.EpisodeId)
    51.               .OnDelete(DeleteBehavior.Restrict);
    53.           // humans
    54.           modelBuilder.Entity<Human>().HasOne(h => h.HomePlanet).WithMany(p => p.Humans);
    55.       }
    57.       public virtual DbSet<Episode> Episodes { get; set; }
    58.       public virtual DbSet<Planet> Planets { get; set; }
    59.       public virtual DbSet<Character> Characters { get; set; }
    60.       public virtual DbSet<CharacterFriend> CharacterFriends { get; set; }
    61.       public virtual DbSet<CharacterEpisode> CharacterEpisodes { get; set; }
    62.       public virtual DbSet<Droid> Droids { get; set; }
    63.       public virtual DbSet<Human> Humans { get; set; }
    64.   }
    65. }

  • Update database seed data

    1. namespace StarWars.Data.EntityFramework.Seed
    2. {
    3.   public static class StarWarsSeedData
    4.   {
    5.       public static void EnsureSeedData(this StarWarsContext db)
    6.       {
    7.           db._logger.LogInformation("Seeding database");
    9.           // episodes
    10.           var newhope = new Episode { Id = 4, Title = "NEWHOPE" };
    11.           var empire = new Episode { Id = 5, Title = "EMPIRE" };
    12.           var jedi = new Episode { Id = 6, Title = "JEDI" };
    13.           var episodes = new List<Episode>
    14.           {
    15.               newhope,
    16.               empire,
    17.               jedi,
    18.           };
    19.           if (!db.Episodes.Any())
    20.           {
    21.               db._logger.LogInformation("Seeding episodes");
    22.               db.Episodes.AddRange(episodes);
    23.               db.SaveChanges();
    24.           }
    26.           // planets
    27.           var tatooine = new Planet { Id = 1, Name = "Tatooine" };
    28.           var alderaan = new Planet { Id = 2, Name = "Alderaan" };
    29.           var planets = new List<Planet>
    30.           {
    31.               tatooine,
    32.               alderaan
    33.           };
    34.           if (!db.Planets.Any())
    35.           {
    36.               db._logger.LogInformation("Seeding planets");
    37.               db.Planets.AddRange(planets);
    38.               db.SaveChanges();
    39.           }
    41.           // humans
    42.           var luke = new Human
    43.           {
    44.               Id = 1000,
    45.               Name = "Luke Skywalker",
    46.               CharacterEpisodes = new List<CharacterEpisode>
    47.               {
    48.                   new CharacterEpisode { Episode = newhope },
    49.                   new CharacterEpisode { Episode = empire },
    50.                   new CharacterEpisode { Episode = jedi }
    51.               },
    52.               HomePlanet = tatooine
    53.           };
    54.           var vader = new Human
    55.           {
    56.               Id = 1001,
    57.               Name = "Darth Vader",
    58.               CharacterEpisodes = new List<CharacterEpisode>
    59.               {
    60.                   new CharacterEpisode { Episode = newhope },
    61.                   new CharacterEpisode { Episode = empire },
    62.                   new CharacterEpisode { Episode = jedi }
    63.               },
    64.               HomePlanet = tatooine
    65.           };
    66.           var han = new Human
    67.           {
    68.               Id = 1002,
    69.               Name = "Han Solo",
    70.               CharacterEpisodes = new List<CharacterEpisode>
    71.               {
    72.                   new CharacterEpisode { Episode = newhope },
    73.                   new CharacterEpisode { Episode = empire },
    74.                   new CharacterEpisode { Episode = jedi }
    75.               },
    76.               HomePlanet = tatooine
    77.           };
    78.           var leia = new Human
    79.           {
    80.               Id = 1003,
    81.               Name = "Leia Organa",
    82.               CharacterEpisodes = new List<CharacterEpisode>
    83.               {
    84.                   new CharacterEpisode { Episode = newhope },
    85.                   new CharacterEpisode { Episode = empire },
    86.                   new CharacterEpisode { Episode = jedi }
    87.               },
    88.               HomePlanet = alderaan
    89.           };
    90.           var tarkin = new Human
    91.           {
    92.               Id = 1004,
    93.               Name = "Wilhuff Tarkin",
    94.               CharacterEpisodes = new List<CharacterEpisode>
    95.               {
    96.                   new CharacterEpisode { Episode = newhope }                    
    97.               },
    98.           };
    99.           var humans = new List<Human>
    100.           {
    101.               luke,
    102.               vader,
    103.               han,
    104.               leia,
    105.               tarkin
    106.           };
    107.           if (!db.Humans.Any())
    108.           {
    109.               db._logger.LogInformation("Seeding humans");                
    110.               db.Humans.AddRange(humans);
    111.               db.SaveChanges();
    112.           }
    114.           // droids
    115.           var threepio = new Droid
    116.           {
    117.               Id = 2000,
    118.               Name = "C-3PO",
    119.               CharacterEpisodes = new List<CharacterEpisode>
    120.               {
    121.                   new CharacterEpisode { Episode = newhope },
    122.                   new CharacterEpisode { Episode = empire },
    123.                   new CharacterEpisode { Episode = jedi }
    124.               },
    125.               PrimaryFunction = "Protocol"
    126.           };
    127.           var artoo = new Droid
    128.           {
    129.               Id = 2001,
    130.               Name = "R2-D2",
    131.               CharacterEpisodes = new List<CharacterEpisode>
    132.               {
    133.                   new CharacterEpisode { Episode = newhope },
    134.                   new CharacterEpisode { Episode = empire },
    135.                   new CharacterEpisode { Episode = jedi }
    136.               },
    137.               PrimaryFunction = "Astromech"
    138.           };
    139.           var droids = new List<Droid>
    140.           {
    141.               threepio,
    142.               artoo
    143.           };
    144.           if (!db.Droids.Any())
    145.           {
    146.               db._logger.LogInformation("Seeding droids");
    147.               db.Droids.AddRange(droids);
    148.               db.SaveChanges();
    149.           }
    151.           // update character's friends
    152.           luke.CharacterFriends = new List<CharacterFriend>
    153.           {
    154.               new CharacterFriend { Friend = han },
    155.               new CharacterFriend { Friend = leia },
    156.               new CharacterFriend { Friend = threepio },
    157.               new CharacterFriend { Friend = artoo }
    158.           };
    159.           vader.CharacterFriends = new List<CharacterFriend>
    160.           {
    161.               new CharacterFriend { Friend = tarkin }
    162.           };
    163.           han.CharacterFriends = new List<CharacterFriend>
    164.           {
    165.               new CharacterFriend { Friend = luke },
    166.               new CharacterFriend { Friend = leia },
    167.               new CharacterFriend { Friend = artoo }
    168.           };
    169.           leia.CharacterFriends = new List<CharacterFriend>
    170.           {
    171.               new CharacterFriend { Friend = luke },
    172.               new CharacterFriend { Friend = han },
    173.               new CharacterFriend { Friend = threepio },
    174.               new CharacterFriend { Friend = artoo }
    175.           };
    176.           tarkin.CharacterFriends = new List<CharacterFriend>
    177.           {
    178.               new CharacterFriend { Friend = vader }
    179.           };
    180.           threepio.CharacterFriends = new List<CharacterFriend>
    181.           {
    182.               new CharacterFriend { Friend = luke },
    183.               new CharacterFriend { Friend = han },
    184.               new CharacterFriend { Friend = leia },
    185.               new CharacterFriend { Friend = artoo }
    186.           };
    187.           artoo.CharacterFriends = new List<CharacterFriend>
    188.           {
    189.               new CharacterFriend { Friend = luke },
    190.               new CharacterFriend { Friend = han },
    191.               new CharacterFriend { Friend = leia }
    192.           };
    193.           var characters = new List<Character>
    194.           {
    195.               luke,
    196.               vader,
    197.               han,
    198.               leia,
    199.               tarkin,
    200.               threepio,
    201.               artoo
    202.           };
    203.           if (!db.CharacterFriends.Any())
    204.           {
    205.               db._logger.LogInformation("Seeding character's friends");
    206.               db.Characters.UpdateRange(characters);
    207.               db.SaveChanges();
    208.           }
    209.       }
    210.   }
    211. }

  • Add ‘Microsoft.EntityFrameworkCore.Tools’ NuGet
    ef-tools-nuget

  • Set ‘StarWars.Data’ as a StartUp project

  • Add ‘Full’ migrations
    ef-full-migration

  • Update database
    ef-update-database-full
    ef-update-database-full-ssms

  • Set ‘StarWars.Api’ as a StartUp project

  • Run ‘StarWars.Api’ to seed database
    ef-seed-full-database
    seeded-full-database-smss

  • Create integration test checking EF configuration and seeded data

    1. namespace StarWars.Tests.Integration.Data.EntityFramework
    2. {
    3.   public class StarWarsContextShould
    4.   {
    5.       [Fact]
    6.       public async void ReturnR2D2Droid()
    7.       {
    8.           // Given
    9.           using (var db = new StarWarsContext())
    10.           {
    11.               // When
    12.               var r2d2 = await db.Droids
    13.                   .Include("CharacterEpisodes.Episode")
    14.                   .Include("CharacterFriends.Friend")
    15.                   .FirstOrDefaultAsync(d => d.Id == 2001);
    17.               // Then
    18.               Assert.NotNull(r2d2);
    19.               Assert.Equal("R2-D2", r2d2.Name);
    20.               Assert.Equal("Astromech", r2d2.PrimaryFunction);
    21.               var episodes = r2d2.CharacterEpisodes.Select(e => e.Episode.Title);
    22.               Assert.Equal(new string[] { "NEWHOPE", "EMPIRE", "JEDI" }, episodes);
    23.               var friends = r2d2.CharacterFriends.Select(e => e.Friend.Name);
    24.               Assert.Equal(new string[] { "Luke Skywalker", "Han Solo", "Leia Organa" }, friends);
    25.           }
    26.       }
    27.   }
    28. }

  • Make sure all tests pass
    all-tests-pass-full-database

  • Update StarWarsQuery with new hero (“R2-D2”) ID (2001)

    1. namespace StarWars.Api.Models
    2. {
    3.   public class StarWarsQuery : ObjectGraphType
    4.   {
    5.       // ...
    6.       public StarWarsQuery(IDroidRepository _droidRepository)
    7.       {
    8.           Field<DroidType>(
    9.             "hero",
    10.             resolve: context => _droidRepository.Get(2001)
    11.           );
    12.       }
    13.   }
    14. }

  • Make sure application still works
    graphiql-full-database

Base/generic repository

  • Create generic entity interface

    1. namespace StarWars.Core.Data
    2. {
    3.   public interface IEntity<TKey>
    4.   {
    5.       TKey Id { get; set; }
    6.   }
    7. }

  • Update models to inherit from IEntity interface (integer based id)

    1. namespace StarWars.Core.Models
    2. {
    3.   public class Character : IEntity<int>
    4.   {
    5.       // ...
    6.   }
    7. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Episode : IEntity<int>
    4.   {
    5.       // ...
    6.   }
    7. }
    1. namespace StarWars.Core.Models
    2. {
    3.   public class Planet : IEntity<int>
    4.   {
    5.       // ...
    6.   }
    7. }

  • Create base/generic repository interface

    1. namespace StarWars.Core.Data
    2. {
    3.   public interface IBaseRepository<TEntity, in TKey>
    4.       where TEntity : class
    5.   {
    6.       Task<List<TEntity>> GetAll();
    7.       Task<TEntity> Get(TKey id);
    8.       TEntity Add(TEntity entity);
    9.       void AddRange(IEnumerable<TEntity> entities);
    10.       void Delete(TKey id);
    11.       void Update(TEntity entity);
    12.       Task<bool> SaveChangesAsync();
    13.   }
    14. }

  • Create Entity Framework base/generic repository

    1. namespace StarWars.Data.EntityFramework.Repositories
    2. {
    3.   public abstract class BaseRepository<TEntity, TKey> : IBaseRepository<TEntity, TKey>
    4.       where TEntity : class, IEntity<TKey>, new()
    5.   {
    6.       protected DbContext _db;
    7.       protected readonly ILogger _logger;
    9.       protected BaseRepository() { }
    11.       protected BaseRepository(DbContext db, ILogger logger)
    12.       {
    13.           _db = db;
    14.           _logger = logger;
    15.       }
    17.       public virtual Task<List<TEntity>> GetAll()
    18.       {
    19.           return _db.Set<TEntity>().ToListAsync();
    20.       }
    22.       public virtual Task<TEntity> Get(TKey id)
    23.       {
    24.           _logger.LogInformation("Get {type} with id = {id}", typeof(TEntity).Name, id);
    25.           return _db.Set<TEntity>().SingleOrDefaultAsync(c => c.Id.Equals(id));
    26.       }
    28.       public virtual TEntity Add(TEntity entity)
    29.       {
    30.           _db.Set<TEntity>().Add(entity);
    31.           return entity;
    32.       }
    34.       public void AddRange(IEnumerable<TEntity> entities)
    35.       {
    36.           _db.Set<TEntity>().AddRange(entities);
    37.       }
    39.       public virtual void Delete(TKey id)
    40.       {
    41.           var entity = new TEntity { Id = id };
    42.           _db.Set<TEntity>().Attach(entity);
    43.           _db.Set<TEntity>().Remove(entity);
    44.       }
    46.       public virtual async Task<bool> SaveChangesAsync()
    47.       {
    48.           return (await _db.SaveChangesAsync()) > 0;
    49.       }
    51.       public virtual void Update(TEntity entity)
    52.       {
    53.           _db.Set<TEntity>().Attach(entity);
    54.           _db.Entry(entity).State = EntityState.Modified;
    55.       }
    56.   }
    57. }

  • Refactor EF Droid repository

    1. namespace StarWars.Core.Data
    2. {
    3.   public interface IDroidRepository : IBaseRepository<Droid, int> { }
    4. }
    1. namespace StarWars.Data.EntityFramework.Repositories
    2. {
    3.   public class DroidRepository : BaseRepository<Droid, int>, IDroidRepository
    4.   {
    5.       public DroidRepository() { }
    7.       public DroidRepository(StarWarsContext db, ILogger<DroidRepository> logger)
    8.           : base(db, logger)
    9.       {
    10.       }
    11.   }
    12. }

  • Refactor in-memeory Droid repository

    1. namespace StarWars.Data.InMemory
    2. {
    3.   public class DroidRepository : IDroidRepository
    4.   {
    5.       private readonly ILogger _logger;
    7.       public DroidRepository() { }
    9.       public DroidRepository(ILogger<DroidRepository> logger)
    10.       {
    11.           _logger = logger;
    12.       }
    14.       private List<Droid> _droids = new List<Droid> {
    15.           new Droid { Id = 1, Name = "R2-D2" }
    16.       };
    18.       public Task<Droid> Get(int id)
    19.       {
    20.           _logger.LogInformation("Get droid with id = {id}", id);
    21.           return Task.FromResult(_droids.FirstOrDefault(droid => droid.Id == id));
    22.       }
    24.       // ...
    25.       // rest of the methods are not implemented
    26.       // for now they are just throwing  NotImplementedException       
    27.   }
    28. }

  • Make sure tests and api stil works

Visual Studio 2017 RTM upgrade

  • Update all NuGet packages for the solution (especially .NET Core v1.1.1)
    vs-2017-rtm-nugets-update

  • Use ‘Package Manger Console’ to fix problems with upgrading ‘Microsoft.NETCore.App’ from v1.1.0 to v.1.1.1 (for some reason Consolidate option does not work). Do upgrade for all projects.
    consolidate-netcore-app

    1. Install-Package Microsoft.NETCore.App

    package-manager-console-netcore-app-upgrade

  • Fix ‘DroidType’ unit test (capitalization of field names)

    1. namespace StarWars.Tests.Unit.Api.Models
    2. {
    3.   public class DroidTypeShould
    4.   {
    5.       [Fact]
    6.       public void HaveIdAndNameFields()
    7.       {
    8.           // When
    9.           var droidType = new DroidType();
    11.           // Then
    12.           Assert.NotNull(droidType);
    13.           Assert.True(droidType.HasField("Id"));
    14.           Assert.True(droidType.HasField("Name"));
    15.       }
    16.   }
    17. }

Repositories

  • Create rest of the repositories (Character, Episode, Human, Planet)

    1. namespace StarWars.Core.Data
    2. {
    3.   public interface IHumanRepository : IBaseRepository<Human, int> { }
    4. }
    1. namespace StarWars.Data.EntityFramework.Repositories
    2. {
    3.   public class HumanRepository : BaseRepository<Human, int>, IHumanRepository
    4.   {
    5.       public HumanRepository() { }
    7.       public HumanRepository(StarWarsContext db, ILogger<HumanRepository> logger)
    8.           : base(db, logger)
    9.       {
    10.       }
    11.   }
    12. }

  • Update base repository with ‘include’ versions

    1. namespace StarWars.Core.Data
    2. {
    3.   public interface IBaseRepository<TEntity, in TKey>
    4.       where TEntity : class
    5.   {
    6.       // ...
    7.       Task<List<TEntity>> GetAll(string include);
    8.       Task<List<TEntity>> GetAll(IEnumerable<string> includes);
    10.       // ...
    12.       Task<TEntity> Get(TKey id, string include);
    13.       Task<TEntity> Get(TKey id, IEnumerable<string> includes);
    14.       // ...
    15.   }
    16. }
    1. namespace StarWars.Data.EntityFramework.Repositories
    2. {
    3.   public abstract class BaseRepository<TEntity, TKey> : IBaseRepository<TEntity, TKey>
    4.       where TEntity : class, IEntity<TKey>, new()
    5.   {
    6.       // ...
    7.       public Task<List<TEntity>> GetAll(string include)
    8.       {
    9.           _logger.LogInformation("Get all {type}s (including {include})", typeof(TEntity).Name, include);
    10.           return _db.Set<TEntity>().Include(include).ToListAsync();
    11.       }
    13.       public Task<List<TEntity>> GetAll(IEnumerable<string> includes)
    14.       {
    15.           _logger.LogInformation("Get all {type}s (including [{includes}])", typeof(TEntity).Name, string.Join(",", includes));
    16.           var query = _db.Set<TEntity>().AsQueryable();
    17.           query = includes.Aggregate(query, (current, include) => current.Include(include));
    18.           return query.ToListAsync();
    19.       }
    21.       // ...
    23.       public Task<TEntity> Get(TKey id, string include)
    24.       {
    25.           _logger.LogInformation("Get {type} with id = {id} (including {include})", typeof(TEntity).Name, id, include);
    26.           return _db.Set<TEntity>().Include(include).SingleOrDefaultAsync(c => c.Id.Equals(id));
    27.       }
    29.       public Task<TEntity> Get(TKey id, IEnumerable<string> includes)
    30.       {
    31.           _logger.LogInformation("Get {type} with id = {id} (including [{include}])", typeof(TEntity).Name, id, string.Join(",", includes));
    32.           var query = _db.Set<TEntity>().AsQueryable();
    33.           query = includes.Aggregate(query, (current, include) => current.Include(include));
    34.           return query.SingleOrDefaultAsync(c => c.Id.Equals(id));
    35.       }
    37.       // ...
    38.   }
    39. }

  • Create repositories CRUD unit tests

    1. namespace StarWars.Tests.Unit.Data.EntityFramework.Repositories
    2. {
    3.   public class HumanRepositoryShould
    4.   {
    5.       private readonly HumanRepository _humanRepository;
    6.       private DbContextOptions<StarWarsContext> _options;
    7.       private Mock<ILogger<StarWarsContext>> _dbLogger;
    8.       public HumanRepositoryShould()
    9.       {
    10.           // Given
    11.           _dbLogger = new Mock<ILogger<StarWarsContext>>();
    12.           _options = new DbContextOptionsBuilder<StarWarsContext>()
    13.               .UseInMemoryDatabase(databaseName: "StarWars_HumanRepositoryShould")
    14.               .Options;
    15.           using (var context = new StarWarsContext(_options, _dbLogger.Object))
    16.           {
    17.               context.EnsureSeedData();
    18.           }
    19.           var starWarsContext = new StarWarsContext(_options, _dbLogger.Object);
    20.           var repoLogger = new Mock<ILogger<HumanRepository>>();
    21.           _humanRepository = new HumanRepository(starWarsContext, repoLogger.Object);
    22.       }
    24.       [Fact]
    25.       public async void ReturnLukeGivenIdOf1000()
    26.       {
    27.           // When
    28.           var luke = await _humanRepository.Get(1000);
    30.           // Then
    31.           Assert.NotNull(luke);
    32.           Assert.Equal("Luke Skywalker", luke.Name);
    33.       }
    35.       [Fact]
    36.       public async void ReturnLukeFriendsAndEpisodes()
    37.       {
    38.           // When
    39.           var character = await _humanRepository.Get(1000, includes: new[] { "CharacterEpisodes.Episode", "CharacterFriends.Friend" });
    41.           // Then
    42.           Assert.NotNull(character);
    43.           Assert.NotNull(character.CharacterEpisodes);
    44.           var episodes = character.CharacterEpisodes.Select(e => e.Episode.Title);
    45.           Assert.Equal(new[] { "NEWHOPE", "EMPIRE", "JEDI" }, episodes);
    46.           Assert.NotNull(character.CharacterFriends);
    47.           var friends = character.CharacterFriends.Select(e => e.Friend.Name);
    48.           Assert.Equal(new[] { "Han Solo", "Leia Organa", "C-3PO", "R2-D2" }, friends);
    49.       }
    51.       [Fact]
    52.       public async void ReturnLukesHomePlanet()
    53.       {
    54.           // When
    55.           var luke = await _humanRepository.Get(1000, include: "HomePlanet");
    57.           // Then
    58.           Assert.NotNull(luke);
    59.           Assert.NotNull(luke.HomePlanet);
    60.           Assert.Equal("Tatooine", luke.HomePlanet.Name);
    61.       }
    63.       [Fact]
    64.       public async void AddNewHuman()
    65.       {
    66.           // Given
    67.           var human10101 = new Human { Id = 10101, Name = "Human10101" };
    69.           // When
    70.           _humanRepository.Add(human10101);
    71.           var saved = await _humanRepository.SaveChangesAsync();
    73.           // Then
    74.           Assert.True(saved);
    75.           using (var db = new StarWarsContext(_options, _dbLogger.Object))
    76.           {
    77.               var human = await db.Humans.FindAsync(10101);
    78.               Assert.NotNull(human);
    79.               Assert.Equal(10101, human.Id);
    80.               Assert.Equal("Human10101", human.Name);
    82.               // Cleanup
    83.               db.Humans.Remove(human);
    84.               await db.SaveChangesAsync();
    85.           }
    86.       }
    88.       [Fact]
    89.       public async void UpdateExistingHuman()
    90.       {
    91.           // Given
    92.           var vader = await _humanRepository.Get(1001);
    93.           vader.Name = "Human1001";
    95.           // When
    96.           _humanRepository.Update(vader);
    97.           var saved = await _humanRepository.SaveChangesAsync();
    99.           // Then
    100.           Assert.True(saved);
    101.           using (var db = new StarWarsContext(_options, _dbLogger.Object))
    102.           {
    103.               var human = await db.Humans.FindAsync(1001);
    104.               Assert.NotNull(human);
    105.               Assert.Equal(1001, human.Id);
    106.               Assert.Equal("Human1001", human.Name);
    108.               // Cleanup
    109.               human.Name = "Darth Vader";
    110.               db.Humans.Update(human);
    111.               await db.SaveChangesAsync();
    112.           }
    113.       }
    115.       [Fact]
    116.       public async void DeleteExistingHuman()
    117.       {
    118.           // Given
    119.           using (var db = new StarWarsContext(_options, _dbLogger.Object))
    120.           {
    121.               var human10102 = new Human { Id = 10102, Name = "Human10102" };
    122.               await db.Humans.AddAsync(human10102);
    123.               await db.SaveChangesAsync();
    124.           }
    126.           // When
    127.           _humanRepository.Delete(10102);
    128.           var saved = await _humanRepository.SaveChangesAsync();
    130.           // Then
    131.           Assert.True(saved);
    132.           using (var db = new StarWarsContext(_options, _dbLogger.Object))
    133.           {
    134.               var deletedHuman = await db.Humans.FindAsync(10101);
    135.               Assert.Null(deletedHuman);
    136.           }
    137.       }
    138.   }
    139. }

  • Check test results
    test-explorer-repositories-crud-tests
    code-coverage-repositories-crud-tests

GraphQL queries

  • TDD (Test First) integration tests for queries at GraphQL Specification by Facebook

    1. namespace StarWars.Tests.Integration.Api.Controllers
    2. {
    3.   public class GraphQLControllerShould
    4.   {
    5.       // ...
    6.       [Fact]
    7.       [Trait("test", "integration")]
    8.       public async void ExecuteHeroNameQuery()
    9.       {
    10.           // Given
    11.           const string query = @"{
    12.               ""query"": 
    13.                   ""query HeroNameQuery {
    14.                       hero {
    15.                           name
    16.                       }
    17.                   }""
    18.           }";
    19.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    21.           // When
    22.           var response = await _client.PostAsync("/graphql", content);
    24.           // Then
    25.           response.EnsureSuccessStatusCode();
    26.           var responseString = await response.Content.ReadAsStringAsync();
    27.           Assert.NotNull(responseString);
    28.           var jobj = JObject.Parse(responseString);
    29.           Assert.NotNull(jobj);
    30.           Assert.Equal("R2-D2", (string)jobj["data"]["hero"]["name"]);
    31.       }
    33.       [Fact]
    34.       [Trait("test", "integration")]
    35.       public async void ExecuteHeroNameAndFriendsQuery()
    36.       {
    37.           // Given
    38.           const string query = @"{
    39.               ""query"":
    40.                   ""query HeroNameAndFriendsQuery {
    41.                       hero {
    42.                           id
    43.                           name
    44.                           friends {
    45.                               id
    46.                               name
    47.                           }
    48.                       }
    49.                   }""
    50.           }";
    51.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    53.           // When
    54.           var response = await _client.PostAsync("/graphql", content);
    56.           // Then
    57.           response.EnsureSuccessStatusCode();
    58.           var responseString = await response.Content.ReadAsStringAsync();
    59.           Assert.NotNull(responseString);
    60.           var jobj = JObject.Parse(responseString);
    61.           Assert.NotNull(jobj);
    62.           Assert.Equal(3, ((JArray)jobj["data"]["hero"]["friends"]).Count);
    63.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["hero"]["friends"][0]["name"]);
    64.           Assert.Equal("Han Solo", (string)jobj["data"]["hero"]["friends"][1]["name"]);
    65.           Assert.Equal("Leia Organa", (string)jobj["data"]["hero"]["friends"][2]["name"]);
    66.       }
    68.       [Fact]
    69.       [Trait("test", "integration")]
    70.       public async void ExecuteNestedQuery()
    71.       {
    72.           // Given
    73.           const string query = @"{
    74.               ""query"":
    75.                   ""query NestedQuery {
    76.                       hero {
    77.                           name
    78.                           friends {
    79.                               name
    80.                               appearsIn
    81.                               friends {
    82.                                   name
    83.                               }
    84.                           }
    85.                       }
    86.                   }""
    87.           }";
    88.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    90.           // When
    91.           var response = await _client.PostAsync("/graphql", content);
    93.           // Then
    94.           response.EnsureSuccessStatusCode();
    95.           var responseString = await response.Content.ReadAsStringAsync();
    96.           Assert.NotNull(responseString);
    97.           var jobj = JObject.Parse(responseString);
    98.           Assert.NotNull(jobj);
    99.           var luke = jobj["data"]["hero"]["friends"][0];
    100.           var episodes = ((JArray) luke["appearsIn"]).Select(e => (string)e).ToArray();
    101.           Assert.Equal(new[] { "NEWHOPE", "EMPIRE", "JEDI" }, episodes);
    102.           Assert.Equal(4, ((JArray)luke["friends"]).Count);
    103.           Assert.Equal("Han Solo", (string)luke["friends"][0]["name"]);
    104.           Assert.Equal("Leia Organa", (string)luke["friends"][1]["name"]);
    105.           Assert.Equal("C-3PO", (string)luke["friends"][2]["name"]);
    106.           Assert.Equal("R2-D2", (string)luke["friends"][3]["name"]);
    107.       }
    109.       [Fact]
    110.       [Trait("test", "integration")]
    111.       public async void ExecuteFetchLukeQuery()
    112.       {
    113.           // Given
    114.           const string query = @"{
    115.               ""query"":
    116.                   ""query FetchLukeQuery {
    117.                       human(id: ""1000"") {
    118.                           name
    119.                       }
    120.                   }
    121.               }""
    122.           }";
    123.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    125.           // When
    126.           var response = await _client.PostAsync("/graphql", content);
    128.           // Then
    129.           response.EnsureSuccessStatusCode();
    130.           var responseString = await response.Content.ReadAsStringAsync();
    131.           Assert.NotNull(responseString);
    132.           var jobj = JObject.Parse(responseString);
    133.           Assert.NotNull(jobj);
    134.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["human"]["name"]);
    135.       }
    137.       [Fact]
    138.       [Trait("test", "integration")]
    139.       public async void ExecuteFetchLukeAliased()
    140.       {
    141.           // Given
    142.           const string query = @"{
    143.               ""query"":
    144.                   ""query FetchLukeAliased {
    145.                       luke: human(id: ""1000"") {
    146.                           name
    147.                       }
    148.                   }
    149.               }""
    150.           }";
    151.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    153.           // When
    154.           var response = await _client.PostAsync("/graphql", content);
    156.           // Then
    157.           response.EnsureSuccessStatusCode();
    158.           var responseString = await response.Content.ReadAsStringAsync();
    159.           Assert.NotNull(responseString);
    160.           var jobj = JObject.Parse(responseString);
    161.           Assert.NotNull(jobj);
    162.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["human"]["name"]);
    163.       }
    165.       [Fact]
    166.       [Trait("test", "integration")]
    167.       public async void ExecuteFetchLukeAndLeiaAliased()
    168.       {
    169.           // Given
    170.           const string query = @"{
    171.               ""query"":
    172.                   ""query FetchLukeAliased {
    173.                       luke: human(id: ""1000"") {
    174.                           name
    175.                       }
    176.                       leia: human(id: ""1003"") {
    177.                           name
    178.                       }
    179.                   }
    180.               }""
    181.           }";
    182.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    184.           // When
    185.           var response = await _client.PostAsync("/graphql", content);
    187.           // Then
    188.           response.EnsureSuccessStatusCode();
    189.           var responseString = await response.Content.ReadAsStringAsync();
    190.           Assert.NotNull(responseString);
    191.           var jobj = JObject.Parse(responseString);
    192.           Assert.NotNull(jobj);
    193.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["luke"]["name"]);
    194.           Assert.Equal("Leia Organa", (string)jobj["data"]["leia"]["name"]);
    195.       }
    197.       [Fact]
    198.       [Trait("test", "integration")]
    199.       public async void ExecuteDuplicateFields()
    200.       {
    201.           // Given
    202.           const string query = @"{
    203.               ""query"":
    204.                   ""query DuplicateFields {
    205.                       luke: human(id: ""1000"") {
    206.                           name
    207.                           homePlanet
    208.                       }
    209.                       leia: human(id: ""1003"") {
    210.                           name
    211.                           homePlanet
    212.                       }
    213.                   }
    214.               }""
    215.           }";
    216.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    218.           // When
    219.           var response = await _client.PostAsync("/graphql", content);
    221.           // Then
    222.           response.EnsureSuccessStatusCode();
    223.           var responseString = await response.Content.ReadAsStringAsync();
    224.           Assert.NotNull(responseString);
    225.           var jobj = JObject.Parse(responseString);
    226.           Assert.NotNull(jobj);
    227.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["luke"]["name"]);
    228.           Assert.Equal("Tatooine", (string)jobj["data"]["luke"]["homePlanet"]);
    229.           Assert.Equal("Leia Organa", (string)jobj["data"]["leia"]["name"]);
    230.           Assert.Equal("Alderaan", (string)jobj["data"]["leia"]["homePlanet"]);
    231.       }
    233.       [Fact]
    234.       [Trait("test", "integration")]
    235.       public async void ExecuteUseFragment()
    236.       {
    237.           // Given
    238.           const string query = @"{
    239.               ""query"":
    240.                   ""query UseFragment {
    241.                       luke: human(id: ""1000"") {
    242.                           ...HumanFragment
    243.                       }
    244.                       leia: human(id: ""1003"") {
    245.                           ...HumanFragment
    246.                       }
    247.                   }
    249.                   fragment HumanFragment on Human {
    250.                       name
    251.                       homePlanet
    252.                   }
    253.               }""
    254.           }";
    255.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    257.           // When
    258.           var response = await _client.PostAsync("/graphql", content);
    260.           // Then
    261.           response.EnsureSuccessStatusCode();
    262.           var responseString = await response.Content.ReadAsStringAsync();
    263.           Assert.NotNull(responseString);
    264.           var jobj = JObject.Parse(responseString);
    265.           Assert.NotNull(jobj);
    266.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["luke"]["name"]);
    267.           Assert.Equal("Tatooine", (string)jobj["data"]["luke"]["homePlanet"]);
    268.           Assert.Equal("Leia Organa", (string)jobj["data"]["leia"]["name"]);
    269.           Assert.Equal("Alderaan", (string)jobj["data"]["leia"]["homePlanet"]);
    270.       }
    272.       [Fact]
    273.       [Trait("test", "integration")]
    274.       public async void ExecuteCheckTypeOfR2()
    275.       {
    276.           // Given
    277.           const string query = @"{
    278.               ""query"":
    279.                   ""query CheckTypeOfR2 {
    280.                       hero {
    281.                           __typename
    282.                           name
    283.                       } 
    284.                   }
    285.               }""
    286.           }";
    287.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    289.           // When
    290.           var response = await _client.PostAsync("/graphql", content);
    292.           // Then
    293.           response.EnsureSuccessStatusCode();
    294.           var responseString = await response.Content.ReadAsStringAsync();
    295.           Assert.NotNull(responseString);
    296.           var jobj = JObject.Parse(responseString);
    297.           Assert.NotNull(jobj);
    298.           Assert.Equal("Droid", (string)jobj["data"]["hero"]["__typename"]);
    299.           Assert.Equal("R2-D2", (string)jobj["data"]["hero"]["name"]);
    300.       }
    302.       [Fact]
    303.       [Trait("test", "integration")]
    304.       public async void ExecuteCheckTypeOfLuke()
    305.       {
    306.           // Given
    307.           const string query = @"{
    308.               ""query"":
    309.                   ""query CheckTypeOfLuke {
    310.                      hero(episode: EMPIRE) {
    311.                           __typename
    312.                           name
    313.                      }
    314.                   }
    315.               }""
    316.           }";
    317.           var content = new StringContent(query, Encoding.UTF8, "application/json");
    319.           // When
    320.           var response = await _client.PostAsync("/graphql", content);
    322.           // Then
    323.           response.EnsureSuccessStatusCode();
    324.           var responseString = await response.Content.ReadAsStringAsync();
    325.           Assert.NotNull(responseString);
    326.           var jobj = JObject.Parse(responseString);
    327.           Assert.NotNull(jobj);
    328.           Assert.Equal("Human", (string)jobj["data"]["hero"]["__typename"]);
    329.           Assert.Equal("Luke Skywalker", (string)jobj["data"]["hero"]["name"]);
    330.       }
    331.   }
    332. }

    facebook-spec-queries-tdd-integration-tests-failed