Add session templates

pwd/session_test.go

@@ -1,10 +1,12 @@
 package pwd
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
 	"github.com/play-with-docker/play-with-docker/config"
+	"github.com/play-with-docker/play-with-docker/docker"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -80,3 +82,190 @@ func TestSessionNew(t *testing.T) {
 	assert.Equal(t, expectedSessions, sessions)
 	assert.True(t, saveCalled)
 }
+
+func TestSessionSetup(t *testing.T) {
+	ips := []string{"10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4", "10.0.0.5"}
+	nextIp := 0
+	swarmInitOnMaster1 := false
+	manager2JoinedHasManager := false
+	manager3JoinedHasManager := false
+	worker1JoinedHasWorker := false
+
+	dock := &mockDocker{}
+	dock.createContainer = func(opts docker.CreateContainerOpts) (string, error) {
+		ip := ips[nextIp]
+		nextIp++
+		return ip, nil
+	}
+	dock.new = func(ip string, cert, key []byte) (docker.DockerApi, error) {
+		if ip == "10.0.0.1" {
+			return &mockDocker{
+				swarmInit: func() (*docker.SwarmTokens, error) {
+					swarmInitOnMaster1 = true
+					return &docker.SwarmTokens{Worker: "worker-join-token", Manager: "manager-join-token"}, nil
+				},
+			}, nil
+		}
+		if ip == "10.0.0.2" {
+			return &mockDocker{
+				swarmInit: func() (*docker.SwarmTokens, error) {
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil, nil
+				},
+				swarmJoin: func(addr, token string) error {
+					if addr == "10.0.0.1:2377" && token == "manager-join-token" {
+						manager2JoinedHasManager = true
+						return nil
+					}
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil
+				},
+			}, nil
+		}
+		if ip == "10.0.0.3" {
+			return &mockDocker{
+				swarmInit: func() (*docker.SwarmTokens, error) {
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil, nil
+				},
+				swarmJoin: func(addr, token string) error {
+					if addr == "10.0.0.1:2377" && token == "manager-join-token" {
+						manager3JoinedHasManager = true
+						return nil
+					}
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil
+				},
+			}, nil
+		}
+		if ip == "10.0.0.4" {
+			return &mockDocker{
+				swarmInit: func() (*docker.SwarmTokens, error) {
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil, nil
+				},
+				swarmJoin: func(addr, token string) error {
+					if addr == "10.0.0.1:2377" && token == "worker-join-token" {
+						worker1JoinedHasWorker = true
+						return nil
+					}
+					assert.Fail(t, "Shouldn't have reached here.")
+					return nil
+				},
+			}, nil
+		}
+		assert.Fail(t, "Shouldn't have reached here.")
+		return nil, nil
+	}
+	tasks := &mockTasks{}
+	broadcast := &mockBroadcast{}
+	storage := &mockStorage{}
+
+	p := NewPWD(dock, tasks, broadcast, storage)
+	s, e := p.SessionNew(time.Hour, "", "")
+	assert.Nil(t, e)
+
+	err := p.SessionSetup(s, SessionSetupConf{
+		Instances: []SessionSetupInstanceConf{
+			{
+				Image:          "franela/dind",
+				IsSwarmManager: true,
+				Hostname:       "manager1",
+			},
+			{
+				IsSwarmManager: true,
+				Hostname:       "manager2",
+			},
+			{
+				Image:          "franela/dind:overlay2-dev",
+				IsSwarmManager: true,
+				Hostname:       "manager3",
+			},
+			{
+				IsSwarmWorker: true,
+				Hostname:      "worker1",
+			},
+			{
+				Hostname: "other",
+			},
+		},
+	})
+	assert.Nil(t, err)
+
+	assert.Equal(t, 5, len(s.Instances))
+
+	manager1 := fmt.Sprintf("%s_manager1", s.Id[:8])
+	manager1Received := *s.Instances[manager1]
+	assert.Equal(t, Instance{
+		Name:         manager1,
+		Image:        "franela/dind",
+		Hostname:     "manager1",
+		IP:           "10.0.0.1",
+		Alias:        "",
+		IsDockerHost: true,
+		session:      s,
+		conn:         manager1Received.conn,
+		docker:       manager1Received.docker,
+	}, manager1Received)
+
+	manager2 := fmt.Sprintf("%s_manager2", s.Id[:8])
+	manager2Received := *s.Instances[manager2]
+	assert.Equal(t, Instance{
+		Name:         manager2,
+		Image:        "franela/dind",
+		Hostname:     "manager2",
+		IP:           "10.0.0.2",
+		Alias:        "",
+		IsDockerHost: true,
+		session:      s,
+		conn:         manager2Received.conn,
+		docker:       manager2Received.docker,
+	}, manager2Received)
+
+	manager3 := fmt.Sprintf("%s_manager3", s.Id[:8])
+	manager3Received := *s.Instances[manager3]
+	assert.Equal(t, Instance{
+		Name:         manager3,
+		Image:        "franela/dind:overlay2-dev",
+		Hostname:     "manager3",
+		IP:           "10.0.0.3",
+		Alias:        "",
+		IsDockerHost: true,
+		session:      s,
+		conn:         manager3Received.conn,
+		docker:       manager3Received.docker,
+	}, manager3Received)
+
+	worker1 := fmt.Sprintf("%s_worker1", s.Id[:8])
+	worker1Received := *s.Instances[worker1]
+	assert.Equal(t, Instance{
+		Name:         worker1,
+		Image:        "franela/dind",
+		Hostname:     "worker1",
+		IP:           "10.0.0.4",
+		Alias:        "",
+		IsDockerHost: true,
+		session:      s,
+		conn:         worker1Received.conn,
+		docker:       worker1Received.docker,
+	}, worker1Received)
+
+	other := fmt.Sprintf("%s_other", s.Id[:8])
+	otherReceived := *s.Instances[other]
+	assert.Equal(t, Instance{
+		Name:         other,
+		Image:        "franela/dind",
+		Hostname:     "other",
+		IP:           "10.0.0.5",
+		Alias:        "",
+		IsDockerHost: true,
+		session:      s,
+		conn:         otherReceived.conn,
+		docker:       otherReceived.docker,
+	}, otherReceived)
+
+	assert.True(t, swarmInitOnMaster1)
+	assert.True(t, manager2JoinedHasManager)
+	assert.True(t, manager3JoinedHasManager)
+	assert.True(t, worker1JoinedHasWorker)
+}