1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// customer.go
package domain

type Customer struct {
    ID string
    Name string
}

// product.go
package domain

type Product struct {
    ID string
    Price int
}

// order.go
package domain

type Order struct {
    ID string
    Customer Customer
    Product Product
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// customer.go
package repository

type ICustomer interface {
    Get(id string) domain.Customer
}

// product.go
package repository

type IProduct interface {
    Get(id string) domain.Product
}

// order.go
package repository

type IOrder interface {
    Save(order Order)
} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// createOrder.go
package usecase

import (
    "domain"            // simplified for convenience
    "domain/repository" // simplified for convenience
)

type CreateOrderArgs struct {
    CustomerID         string
    ProductID          string
    CustomerRepository repository.ICustomer
    ProductRepository  repository.IProduct
    OrderRepository    repository.IOrder
}

func CreateOrder(args CreateOrderArgs) domain.Order {
    customer := args.CustomerRepository.Get(args.CustomerID)
    product := args.ProductRepository.Get(args.ProductID)
    order := domain.Order{
        ID: "123",
        Customer: customer,
        Product: product,
    }
    args.OrderRepository.Save(order)
    return order
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// controller.go
package adapter

import (
    "repository" // simplified for convenience
    "usecase"    // simplified for convenience

    "github.com/gin-gonic/gin"

)

var (
    customerRepository = repository.Customer{}
    productRepository  = repository.Product{}
    orderRepository    = repository.Order{}
)

type Controller struct{}

func Router() *gin.Engine {
    r := gin.Default()
    ctrl := Controller{}
    r.POST("/order", ctrl.createOrder)
    return r
}

func (ctrl Controller) createOrder(c *gin.Context) {
    customerID := c.Query("customerId")
    productID := c.Query("productId")
    args := usecase.CreateOrderArgs{
        CustomerID:         customerID,
        ProductID:          productID,
        CustomerRepository: customerRepository,
        ProductRepository:  productRepository,
        OrderRepository:    orderRepository,
    }
    order := usecase.CreateOrder(args)
    c.JSON(200, order)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

~/go/src/github.com/resotto/goilerplate (master) > go test ./internal/app/...
?       github.com/resotto/goilerplate/internal/app/adapter     [no test files]
?       github.com/resotto/goilerplate/internal/app/adapter/postgresql  [no test files]
?       github.com/resotto/goilerplate/internal/app/adapter/postgresql/model    [no test files]
?       github.com/resotto/goilerplate/internal/app/adapter/repository  [no test files]
?       github.com/resotto/goilerplate/internal/app/adapter/service     [no test files]
?       github.com/resotto/goilerplate/internal/app/application/service [no test files]
ok      github.com/resotto/goilerplate/internal/app/application/usecase 0.204s
ok      github.com/resotto/goilerplate/internal/app/domain      0.273s
?       github.com/resotto/goilerplate/internal/app/domain/factory      [no test files]
?       github.com/resotto/goilerplate/internal/app/domain/repository   [no test files]
?       github.com/resotto/goilerplate/internal/app/domain/valueobject  [no test files]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

.
├── internal
│   └── app
│       ├── application
│       │   └── usecase
│       │       ├── ticker.go      # Usecase
│       │       └── ticker_test.go # Usecase Test
│       └── domain
│           ├── parameter.go       # Entity
│           └── parameter_test.go  # Entity Test
└── testdata
    └── exchange_mock.go           # Mock if needed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

.
└── internal
    └── app
        └── domain
            ├── parameter.go      # Target Entity
            └── parameter_test.go # Test</code> 

// parameter_test.go
package domain_test

import (
    "testing"

    "github.com/resotto/goilerplate/internal/app/domain"

)

func TestParameter(t *testing.T) {
    tests := []struct {
        name                       string
        funds, btc                 int
        expectedfunds, expectedbtc int
    }{
        {"more funds than btc", 1000, 0, 1000, 0},
        {"same amount", 100, 100, 100, 100},
        {"much more funds than btc", 100000, 20, 100000, 20},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            parameter := domain.Parameter{
                Funds: tt.funds,
                Btc:   tt.btc,
            }
            if parameter.Funds != tt.expectedfunds {
                t.Errorf("got %q, want %q", parameter.Funds, tt.expectedfunds)
            }
            if parameter.Btc != tt.expectedbtc {
                t.Errorf("got %q, want %q", parameter.Btc, tt.expectedbtc)
            }
        })
    }

}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

.
├── internal
│   └── app
│       └── application
│           ├── service
│           │   └── exchange.go    # Application Service Interface
│           └── usecase
│               ├── ticker.go      # Target Usecase
│               └── ticker_test.go # Test
└── testdata
    └── exchange_mock.go           # Mock of Application Service Interface</code> 

// exchange_mock.go
package testdata

import "github.com/resotto/goilerplate/internal/app/domain/valueobject"

// MExchange is mock of service.IExchange
type MExchange struct{}

// Ticker is mock implementation of service.IExchange.Ticker()
func (e MExchange) Ticker(p valueobject.Pair) valueobject.Ticker {
    return valueobject.Ticker{
        Sell:      "1000",
        Buy:       "1000",
        High:      "2000",
        Low:       "500",
        Last:      "1200",
        Vol:       "20",
        Timestamp: "1600769562",
    }
}

// Ohlc is mock implementation of service.IExchange.Ohlc()
func (e MExchange) Ohlc(p valueobject.Pair, t valueobject.Timeunit) []valueobject.CandleStick {
    cs := make([]valueobject.CandleStick, 0)
    return append(cs, valueobject.CandleStick{
        Open:      "1000",
        High:      "2000",
        Low:       "500",
        Close:     "1500",
        Volume:    "30",
        Timestamp: "1600769562",
    })
}

// ticker_test.go
package usecase_test

import (
    "testing"

    "github.com/resotto/goilerplate/internal/app/application/usecase"
    "github.com/resotto/goilerplate/internal/app/domain/valueobject"
    "github.com/resotto/goilerplate/testdata"

)

func TestTicker(t *testing.T) {
    tests := []struct {
        name              string
        pair              valueobject.Pair
        expectedsell      string
        expectedbuy       string
        expectedhigh      string
        expectedlow       string
        expectedlast      string
        expectedvol       string
        expectedtimestamp string
    }{
        {"btcjpy", valueobject.BtcJpy, "1000", "1000", "2000", "500", "1200", "20", "1600769562"},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            mexchange := testdata.MExchange{} // using Mock
            result := usecase.Ticker(mexchange, tt.pair)
            if result.Sell != tt.expectedsell {
                t.Errorf("got %q, want %q", result.Sell, tt.expectedsell)
            }
            if result.Buy != tt.expectedbuy {
                t.Errorf("got %q, want %q", result.Buy, tt.expectedbuy)
            }
            if result.High != tt.expectedhigh {
                t.Errorf("got %q, want %q", result.High, tt.expectedhigh)
            }
            if result.Low != tt.expectedlow {
                t.Errorf("got %q, want %q", result.Low, tt.expectedlow)
            }
            if result.Last != tt.expectedlast {
                t.Errorf("got %q, want %q", result.Last, tt.expectedlast)
            }
            if result.Vol != tt.expectedvol {
                t.Errorf("got %q, want %q", result.Vol, tt.expectedvol)
            }
            if result.Timestamp != tt.expectedtimestamp {
                t.Errorf("got %q, want %q", result.Timestamp, tt.expectedtimestamp)
            }
        })
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

name: test

on:
  push:
    branches:
      - master
    paths-ignore:
      - "**/*.md"
  pull_request:
    branches:
      - master

jobs:
  gochk-goilerplate:
    runs-on: ubuntu-latest
    container:
      image: docker://ghcr.io/resotto/gochk:latest
    steps:
      - name: Clone Goilerplate
        uses: actions/checkout@v2
        with:
          repository: {{ github.repository }}
            - name: Run Gochk
          run: |
            /go/bin/gochk -c=/go/src/github.com/resotto/gochk/configs/config.json

1
2
3
4
5
6
7

FROM postgres

EXPOSE 5432

COPY ./init.sql /docker-entrypoint-initdb.d/</code> 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

create table parameters (
    id integer primary key,
    funds integer,
    btc integer
);

insert into parameters values (1, 10000, 10);

create table persons (
    person_id uuid primary key,
    name text not null,
    weight integer
);

create table card_brands (
    brand text primary key
);

create table cards (
    card_id uuid primary key,
    brand text references card_brands(brand) on update cascade
);

create table orders (
    order_id uuid primary key,
    person_id uuid references persons(person_id)
);

create table payments (
    order_id uuid primary key references orders(order_id),
    card_id uuid references cards(card_id)
);

insert into persons values ('f3bf75a9-ea4c-4f57-9161-cfa8f96e2d0b', 'Jerry', 1);

insert into card_brands values ('VISA'), ('AMEX');

insert into cards values ('3224ebc0-0a6e-4e22-9ce8-c6564a1bb6a1', 'VISA');

insert into orders values ('722b694c-984c-4208-bddd-796553cf83e1', 'f3bf75a9-ea4c-4f57-9161-cfa8f96e2d0b');

insert into payments values ('722b694c-984c-4208-bddd-796553cf83e1', '3224ebc0-0a6e-4e22-9ce8-c6564a1bb6a1');