github.com/nvkalinin/business-calendar@v1.0.2-0.20220515154925-e7df8a3d0c34/cmd/server_test.go (about)

     1  package cmd
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  	"syscall"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/jessevdk/go-flags"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestServerCmd(t *testing.T) {
    16  	_, a, port := newApp(t, nil)
    17  	defer a.shutdown()
    18  
    19  	go a.run()
    20  	waitForHTTP(port)
    21  
    22  	status, _ := getBody(t, fmt.Sprintf("http://localhost:%d/ping", port))
    23  	assert.Equal(t, 200, status)
    24  
    25  	status, _ = getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/2022", port))
    26  	assert.Equal(t, 404, status)
    27  }
    28  
    29  func TestServerCmd_syncOnStart(t *testing.T) {
    30  	_, a, port := newApp(t, func(cmd *Server) {
    31  		cmd.SyncOnStart = []string{"2021", "current", "next"}
    32  		cmd.Source.Override = "testdata/override.yml"
    33  	})
    34  	defer a.shutdown()
    35  
    36  	go a.run()
    37  	waitForHTTP(port)
    38  	time.Sleep(200 * time.Millisecond) // должно быть достаточно для generic календаря
    39  
    40  	// Из generic-календаря.
    41  	status, json := getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/2021/01/01", port))
    42  	expJson := `{
    43  		"weekDay": "fri",
    44  		"working": true,
    45  		"type": "normal"
    46  	}`
    47  	assert.Equal(t, 200, status)
    48  	assert.JSONEq(t, expJson, json)
    49  
    50  	// Из override.yml.
    51  	status, json = getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/2021/01/02", port))
    52  	expJson = `{
    53  		"weekDay": "sat",
    54  		"working": true,
    55  		"type": "normal",
    56  		"desc": "работаем"
    57  	}`
    58  	assert.Equal(t, 200, status)
    59  	assert.JSONEq(t, expJson, json)
    60  
    61  	y := time.Now().Year()
    62  
    63  	status, _ = getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/%d/01/01", port, y))
    64  	assert.Equal(t, 200, status)
    65  
    66  	status, _ = getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/%d/01/01", port, y+1))
    67  	assert.Equal(t, 200, status)
    68  }
    69  
    70  func TestServerCmd_autoSync(t *testing.T) {
    71  	_, a, port := newApp(t, func(cmd *Server) {
    72  		cmd.SyncAt = time.Now().Add(1 * time.Second).Format("15:04:05")
    73  	})
    74  	defer a.shutdown()
    75  
    76  	go a.run()
    77  	waitForHTTP(port)
    78  	time.Sleep(1 * time.Second)
    79  
    80  	y := time.Now().Year()
    81  	status, _ := getBody(t, fmt.Sprintf("http://localhost:%d/api/cal/%d/01/01", port, y))
    82  	assert.Equal(t, 200, status)
    83  }
    84  
    85  func TestServerCmd_signalsAndShutdown(t *testing.T) {
    86  	cmd, _, port := newApp(t, nil)
    87  
    88  	go func() {
    89  		err := cmd.Execute([]string{})
    90  		require.NoError(t, err)
    91  	}()
    92  	waitForHTTP(port)
    93  
    94  	status, _ := getBody(t, fmt.Sprintf("http://localhost:%d/ping", port))
    95  	assert.Equal(t, 200, status)
    96  
    97  	err := syscall.Kill(syscall.Getpid(), syscall.SIGINT)
    98  	require.NoError(t, err)
    99  	time.Sleep(500 * time.Millisecond) // Должно хватить на звершение.
   100  
   101  	cl := &http.Client{
   102  		Timeout: 100 * time.Millisecond,
   103  	}
   104  	_, err = cl.Get(fmt.Sprintf("http://localhost:%d/ping", port))
   105  	require.Error(t, err)
   106  }
   107  
   108  func TestServerCmd_fail(t *testing.T) {
   109  	cmd := &Server{}
   110  	_, _ = flags.ParseArgs(cmd, []string{
   111  		"--store.engine=foo",
   112  	})
   113  	_, err := cmd.makeApp()
   114  	assert.ErrorContains(t, err, "unknown store engine")
   115  
   116  	cmd = &Server{}
   117  	_, _ = flags.ParseArgs(cmd, []string{
   118  		"--store.engine=memory",
   119  		"--source.parser=foo",
   120  	})
   121  	_, err = cmd.makeApp()
   122  	assert.ErrorContains(t, err, "unknown parser")
   123  
   124  	cmd = &Server{}
   125  	_, _ = flags.ParseArgs(cmd, []string{
   126  		"--store.engine=memory",
   127  		"--source.parser=consultant",
   128  		"--sync-at=foo",
   129  	})
   130  	_, err = cmd.makeApp()
   131  	assert.ErrorContains(t, err, "sync at")
   132  
   133  	cmd = &Server{}
   134  	_, _ = flags.ParseArgs(cmd, []string{
   135  		"--store.engine=memory",
   136  		"--source.parser=consultant",
   137  		"--sync-at=05:00",
   138  		"--sync-on-start=foo",
   139  	})
   140  	_, err = cmd.makeApp()
   141  	assert.ErrorContains(t, err, "sync on start")
   142  
   143  	cmd = &Server{}
   144  	_, _ = flags.ParseArgs(cmd, []string{
   145  		"--store.engine=memory",
   146  		"--source.parser=consultant",
   147  		"--sync-at=05:00",
   148  		"--sync-on-start=2020", "--sync-on-start=current",
   149  	})
   150  	_, err = cmd.makeApp()
   151  	assert.NoError(t, err)
   152  }