Golang bosh-mbus.NewRequest类(方法)实例源码

func TestRunHandlesAPingMessage(t *testing.T) {
	taskService := &testtask.FakeService{}
	req := boshmbus.NewRequest("reply to me!", "ping", []byte("some payload"))
	expectedResp := boshmbus.Response{Value: "pong"}

	assertResponseForRequest(t, taskService, req, expectedResp)
}

func TestRunHandlesGetTaskMessageWhenPayloadDoesNotHaveTaskId(t *testing.T) {
	taskService := &testtask.FakeService{
		Tasks: map[string]boshtask.Task{},
	}

	req := boshmbus.NewRequest("reply to me!", "get_task", []byte(`{"arguments":[]}`))
	expectedResp := boshmbus.Response{Exception: "Error finding task, not enough arguments"}

	assertResponseForRequest(t, taskService, req, expectedResp)
}

func TestRunHandlesGetTaskMessageWhenTaskIsNotFound(t *testing.T) {
	taskService := &testtask.FakeService{
		Tasks: map[string]boshtask.Task{},
	}

	req := boshmbus.NewRequest("reply to me!", "get_task", []byte(`{"arguments":["57"]}`))
	expectedResp := boshmbus.Response{Exception: "Task with id 57 could not be found"}

	assertResponseForRequest(t, taskService, req, expectedResp)
}

func TestRunHandlesGetTaskMessage(t *testing.T) {
	taskService := &testtask.FakeService{
		Tasks: map[string]boshtask.Task{
			"57": boshtask.Task{Id: "found-57-task-id", State: boshtask.TaskStateFailed},
		},
	}

	req := boshmbus.NewRequest("reply to me!", "get_task", []byte(`{"arguments":["57"]}`))
	expectedResp := boshmbus.Response{State: boshtask.TaskStateFailed, AgentTaskId: "found-57-task-id"}

	assertResponseForRequest(t, taskService, req, expectedResp)
}

func TestRunHandlesAnApplyMessage(t *testing.T) {
	taskService := &testtask.FakeService{
		StartTaskStartedTask: boshtask.Task{
			Id:    "some-task-id",
			State: "running",
		},
	}

	req := boshmbus.NewRequest("reply to me!", "apply", []byte("some payload"))
	expectedResp := boshmbus.Response{State: "running", AgentTaskId: "some-task-id"}

	assertResponseForRequestWithTask(t, taskService, req, expectedResp)
}

func TestRunRespondsWithExceptionWhenTheMethodIsUnknown(t *testing.T) {
	req := boshmbus.NewRequest("reply to me", "gibberish", []byte{})

	settings, handler, platform, taskService, actionFactory := getAgentDependencies()
	agent := New(settings, handler, platform, taskService, actionFactory)

	err := agent.Run()
	assert.NoError(t, err)
	assert.True(t, handler.ReceivedRun)

	resp := handler.Func(req)

	boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"unknown message gibberish"}}`)
}

func TestDispatchRespondsWithExceptionWhenTheMethodIsUnknown(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	req := boshmbus.NewRequest("reply to me", "gibberish", []byte{})

	actionFactory.CreateErr = true

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)

	resp := dispatcher.Dispatch(req)

	boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"unknown message gibberish"}}`)
	assert.Equal(t, actionFactory.CreateMethod, "gibberish")
}

func TestRunSetsTheDispatcherAsMessageHandler(t *testing.T) {
	deps, agent := buildAgent()
	deps.actionDispatcher.DispatchResp = boshmbus.NewValueResponse("pong")

	err := agent.Run()

	assert.NoError(t, err)
	assert.True(t, deps.handler.ReceivedRun)

	req := boshmbus.NewRequest("reply to me!", "some action", []byte("some payload"))
	resp := deps.handler.Func(req)

	assert.Equal(t, deps.actionDispatcher.DispatchReq, req)
	assert.Equal(t, resp, deps.actionDispatcher.DispatchResp)
}

func TestDispatchHandlesSynchronousActionWhenErr(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	// when action returns an error
	actionFactory.CreateAction = &fakeaction.TestAction{}
	actionRunner.RunErr = errors.New("some error")

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)

	req := boshmbus.NewRequest("reply to me!", "some action", []byte("some payload"))
	resp := dispatcher.Dispatch(req)
	expectedJson := fmt.Sprintf("{\"exception\":{\"message\":\"Action Failed %s: some error\"}}", req.Method)
	boshassert.MatchesJsonString(t, resp, expectedJson)
	assert.Equal(t, actionFactory.CreateMethod, "some action")
}

func TestRunSetsTheDispatcherAsMessageHandler(t *testing.T) {
	settings, logger, handler, platform, actionDispatcher := getAgentDependencies()
	actionDispatcher.DispatchResp = boshmbus.NewValueResponse("pong")

	agent := New(settings, logger, handler, platform, actionDispatcher)
	err := agent.Run()

	assert.NoError(t, err)
	assert.True(t, handler.ReceivedRun)

	req := boshmbus.NewRequest("reply to me!", "some action", []byte("some payload"))
	resp := handler.Func(req)

	assert.Equal(t, actionDispatcher.DispatchReq, req)
	assert.Equal(t, resp, actionDispatcher.DispatchResp)
}

func TestDispatchHandlesSynchronousAction(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	// when action is successful
	actionFactory.CreateAction = &fakeaction.TestAction{
		Asynchronous: false,
	}
	actionRunner.RunValue = "some value"

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)

	req := boshmbus.NewRequest("reply to me!", "some action", []byte("some payload"))
	resp := dispatcher.Dispatch(req)
	assert.Equal(t, req.Method, actionFactory.CreateMethod)
	assert.Equal(t, req.GetPayload(), actionRunner.RunPayload)
	assert.Equal(t, boshmbus.NewValueResponse("some value"), resp)
}

func TestDispatchHandlesAsynchronousAction(t *testing.T) {
	logger, taskService, actionFactory, actionRunner := getActionDispatcherDependencies()

	taskService.StartTaskStartedTask = boshtask.Task{Id: "found-57-id", State: boshtask.TaskStateDone}
	actionFactory.CreateAction = &fakeaction.TestAction{
		Asynchronous: true,
	}
	actionRunner.RunValue = "some-task-result-value"

	dispatcher := NewActionDispatcher(logger, taskService, actionFactory, actionRunner)
	req := boshmbus.NewRequest("reply to me!", "some async action", []byte("some payload"))
	resp := dispatcher.Dispatch(req)

	boshassert.MatchesJsonString(t, resp, `{"value":{"agent_task_id":"found-57-id","state":"done"}}`)

	value, err := taskService.StartTaskFunc()
	assert.NoError(t, err)
	assert.Equal(t, "some-task-result-value", value)

	assert.Equal(t, req.Method, actionFactory.CreateMethod)
	assert.Equal(t, req.GetPayload(), actionRunner.RunPayload)
	assert.Equal(t, actionFactory.CreateMethod, "some async action")
}

func TestRunHandlesGetStateMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "get_state", []byte(`{}`))
	assertRequestIsProcessedSynchronously(t, req)
}

func TestRunHandlesGetTaskMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "get_task", []byte(`{"arguments":["57"]}`))
	assertRequestIsProcessedSynchronously(t, req)
}

func TestRunHandlesPingMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "ping", []byte("some payload"))
	assertRequestIsProcessedSynchronously(t, req)
}

func TestRunHandlesSshMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "ssh", []byte(`{"arguments":["setup",{"user":"foo","password":"bar"}]}`))
	assertRequestIsProcessedSynchronously(t, req)
}

func TestRunHandlesLogsMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "fetch_logs", []byte("some payload"))
	assertRequestIsProcessedAsynchronously(t, req)
}

func TestRunHandlesMigrateDiskMessage(t *testing.T) {
	req := boshmbus.NewRequest("reply to me!", "migrate_disk", []byte("some payload"))
	assertRequestIsProcessedAsynchronously(t, req)
}