github.com/leowmjw/otto@v0.2.1-0.20160126165905-6400716cf085/rpc/app_test.go (about)

     1  package rpc
     2  
     3  import (
     4  	"io"
     5  	"reflect"
     6  	"testing"
     7  
     8  	"github.com/hashicorp/otto/app"
     9  	"github.com/hashicorp/otto/appfile"
    10  	"github.com/hashicorp/otto/ui"
    11  )
    12  
    13  func TestApp_impl(t *testing.T) {
    14  	var _ app.App = new(App)
    15  	var _ io.Closer = new(App)
    16  }
    17  
    18  func TestApp_meta(t *testing.T) {
    19  	client, server, streams := testNewClientServer(t)
    20  	defer streams.Close()
    21  	defer client.Close()
    22  
    23  	appMock := server.AppFunc().(*app.Mock)
    24  	appReal, err := client.App()
    25  	if err != nil {
    26  		t.Fatalf("err: %s", err)
    27  	}
    28  
    29  	appMock.MetaResult = &app.Meta{
    30  		Tuples: []app.Tuple{
    31  			app.Tuple{"test", "test", "test"},
    32  		},
    33  	}
    34  
    35  	actual, err := appReal.Meta()
    36  	if !appMock.MetaCalled {
    37  		t.Fatal("should be called")
    38  	}
    39  	if err != nil {
    40  		t.Fatalf("bad: %#v", err)
    41  	}
    42  
    43  	expected := appMock.MetaResult
    44  	if !reflect.DeepEqual(actual, expected) {
    45  		t.Fatalf("bad: %#v", actual)
    46  	}
    47  }
    48  
    49  func TestApp_implicit(t *testing.T) {
    50  	client, server, streams := testNewClientServer(t)
    51  	defer streams.Close()
    52  	defer client.Close()
    53  
    54  	appMock := server.AppFunc().(*app.Mock)
    55  	appReal, err := client.App()
    56  	if err != nil {
    57  		t.Fatalf("err: %s", err)
    58  	}
    59  
    60  	appMock.ImplicitResult = &appfile.File{
    61  		ID: "FOO",
    62  	}
    63  
    64  	actual, err := appReal.Implicit(new(app.Context))
    65  	if !appMock.ImplicitCalled {
    66  		t.Fatal("should be called")
    67  	}
    68  	if err != nil {
    69  		t.Fatalf("bad: %#v", err)
    70  	}
    71  
    72  	expected := appMock.ImplicitResult
    73  	if !reflect.DeepEqual(actual, expected) {
    74  		t.Fatalf("bad: %#v", actual)
    75  	}
    76  }
    77  
    78  func TestApp_compile(t *testing.T) {
    79  	client, server, streams := testNewClientServer(t)
    80  	defer streams.Close()
    81  	defer client.Close()
    82  
    83  	appMock := server.AppFunc().(*app.Mock)
    84  	appReal, err := client.App()
    85  	if err != nil {
    86  		t.Fatalf("err: %s", err)
    87  	}
    88  
    89  	appMock.CompileResult = &app.CompileResult{Version: 42}
    90  
    91  	actual, err := appReal.Compile(new(app.Context))
    92  	if !appMock.CompileCalled {
    93  		t.Fatal("compile should be called")
    94  	}
    95  	if err != nil {
    96  		t.Fatalf("bad: %#v", err)
    97  	}
    98  
    99  	expected := appMock.CompileResult
   100  	if !reflect.DeepEqual(actual, expected) {
   101  		t.Fatalf("bad: %#v", actual)
   102  	}
   103  }
   104  
   105  func TestApp_compileUi(t *testing.T) {
   106  	client, server, streams := testNewClientServer(t)
   107  	defer streams.Close()
   108  	defer client.Close()
   109  
   110  	appMock := server.AppFunc().(*app.Mock)
   111  	appReal, err := client.App()
   112  	if err != nil {
   113  		t.Fatalf("err: %s", err)
   114  	}
   115  
   116  	appMock.CompileFunc = func(ctx *app.Context) (*app.CompileResult, error) {
   117  		ctx.Ui.Message("HELLO!")
   118  		return nil, nil
   119  	}
   120  
   121  	ui := new(ui.Mock)
   122  	ctx := new(app.Context)
   123  	ctx.Ui = ui
   124  
   125  	_, err = appReal.Compile(ctx)
   126  	if !appMock.CompileCalled {
   127  		t.Fatal("compile should be called")
   128  	}
   129  	if err != nil {
   130  		t.Fatalf("bad: %#v", err)
   131  	}
   132  
   133  	if ui.MessageBuf[0] != "HELLO!" {
   134  		t.Fatalf("bad: %#v", ui)
   135  	}
   136  }
   137  
   138  func TestApp_build(t *testing.T) {
   139  	client, server, streams := testNewClientServer(t)
   140  	defer streams.Close()
   141  	defer client.Close()
   142  
   143  	appMock := server.AppFunc().(*app.Mock)
   144  	appReal, err := client.App()
   145  	if err != nil {
   146  		t.Fatalf("err: %s", err)
   147  	}
   148  
   149  	err = appReal.Build(new(app.Context))
   150  	if !appMock.BuildCalled {
   151  		t.Fatal("should be called")
   152  	}
   153  	if err != nil {
   154  		t.Fatalf("bad: %#v", err)
   155  	}
   156  }
   157  
   158  func TestApp_deploy(t *testing.T) {
   159  	client, server, streams := testNewClientServer(t)
   160  	defer streams.Close()
   161  	defer client.Close()
   162  
   163  	appMock := server.AppFunc().(*app.Mock)
   164  	appReal, err := client.App()
   165  	if err != nil {
   166  		t.Fatalf("err: %s", err)
   167  	}
   168  
   169  	err = appReal.Deploy(new(app.Context))
   170  	if !appMock.DeployCalled {
   171  		t.Fatal("should be called")
   172  	}
   173  	if err != nil {
   174  		t.Fatalf("bad: %#v", err)
   175  	}
   176  }
   177  
   178  func TestApp_dev(t *testing.T) {
   179  	client, server, streams := testNewClientServer(t)
   180  	defer streams.Close()
   181  	defer client.Close()
   182  
   183  	appMock := server.AppFunc().(*app.Mock)
   184  	appReal, err := client.App()
   185  	if err != nil {
   186  		t.Fatalf("err: %s", err)
   187  	}
   188  
   189  	err = appReal.Dev(new(app.Context))
   190  	if !appMock.DevCalled {
   191  		t.Fatal("should be called")
   192  	}
   193  	if err != nil {
   194  		t.Fatalf("bad: %#v", err)
   195  	}
   196  }
   197  
   198  func TestApp_devDep(t *testing.T) {
   199  	client, server, streams := testNewClientServer(t)
   200  	defer streams.Close()
   201  	defer client.Close()
   202  
   203  	appMock := server.AppFunc().(*app.Mock)
   204  	appReal, err := client.App()
   205  	if err != nil {
   206  		t.Fatalf("err: %s", err)
   207  	}
   208  
   209  	_, err = appReal.DevDep(new(app.Context), new(app.Context))
   210  	if !appMock.DevDepCalled {
   211  		t.Fatal("should be called")
   212  	}
   213  	if err != nil {
   214  		t.Fatalf("bad: %#v", err)
   215  	}
   216  }