github.com/leg100/ots@v0.0.7-0.20210919080622-034055ced4bd/agent/spooler_test.go (about)

     1  package agent
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/go-logr/logr"
     8  	"github.com/leg100/go-tfe"
     9  	"github.com/leg100/ots"
    10  	"github.com/leg100/ots/mock"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  type mockRunLister struct {
    16  	runs []*ots.Run
    17  }
    18  
    19  func (l *mockRunLister) List(opts ots.RunListOptions) (*ots.RunList, error) {
    20  	return &ots.RunList{Items: l.runs}, nil
    21  }
    22  
    23  type mockSubscription struct {
    24  	c chan ots.Event
    25  }
    26  
    27  func (s *mockSubscription) C() <-chan ots.Event { return s.c }
    28  
    29  func (s *mockSubscription) Close() error { return nil }
    30  
    31  // TestSpooler_New tests the spooler constructor
    32  func TestSpooler_New(t *testing.T) {
    33  	want := &ots.Run{ID: "run-123", Status: tfe.RunPlanQueued}
    34  
    35  	spooler, err := NewSpooler(
    36  		&mockRunLister{runs: []*ots.Run{want}},
    37  		&mock.EventService{},
    38  		logr.Discard(),
    39  	)
    40  	require.NoError(t, err)
    41  
    42  	assert.Equal(t, want, <-spooler.queue)
    43  }
    44  
    45  // TestSpooler_Start tests the spooler daemon start op
    46  func TestSpooler_Start(t *testing.T) {
    47  	spooler := &SpoolerDaemon{
    48  		EventService: &mock.EventService{
    49  			SubscribeFn: func(id string) ots.Subscription {
    50  				return &mockSubscription{}
    51  			},
    52  		},
    53  		Logger: logr.Discard(),
    54  	}
    55  
    56  	ctx, cancel := context.WithCancel(context.Background())
    57  
    58  	done := make(chan struct{})
    59  	go func() {
    60  		spooler.Start(ctx)
    61  		done <- struct{}{}
    62  	}()
    63  
    64  	cancel()
    65  
    66  	<-done
    67  }
    68  
    69  // TestSpooler_GetJob tests retrieving a job from the spooler with a
    70  // pre-populated queue
    71  func TestSpooler_GetJob(t *testing.T) {
    72  	want := &ots.Run{ID: "run-123", Status: tfe.RunPlanQueued}
    73  
    74  	spooler := &SpoolerDaemon{queue: make(chan ots.Job, 1)}
    75  	spooler.queue <- want
    76  
    77  	assert.Equal(t, want, <-spooler.GetJob())
    78  }
    79  
    80  // TestSpooler_GetJobFromEvent tests retrieving a job from the spooler after an
    81  // event is received
    82  func TestSpooler_GetJobFromEvent(t *testing.T) {
    83  	want := &ots.Run{ID: "run-123", Status: tfe.RunPlanQueued}
    84  
    85  	sub := mockSubscription{c: make(chan ots.Event, 1)}
    86  
    87  	spooler := &SpoolerDaemon{
    88  		queue: make(chan ots.Job, 1),
    89  		EventService: &mock.EventService{
    90  			SubscribeFn: func(id string) ots.Subscription {
    91  				return &sub
    92  			},
    93  		},
    94  		Logger: logr.Discard(),
    95  	}
    96  
    97  	go spooler.Start(context.Background())
    98  
    99  	// send event
   100  	sub.c <- ots.Event{Type: ots.PlanQueued, Payload: want}
   101  
   102  	assert.Equal(t, want, <-spooler.GetJob())
   103  }
   104  
   105  // TestSpooler_GetJobFromCancelation tests retrieving a job from the spooler
   106  // after a cancelation is received
   107  func TestSpooler_GetJobFromCancelation(t *testing.T) {
   108  	want := &ots.Run{ID: "run-123", Status: tfe.RunCanceled}
   109  
   110  	sub := mockSubscription{c: make(chan ots.Event, 1)}
   111  
   112  	spooler := &SpoolerDaemon{
   113  		cancelations: make(chan ots.Job, 1),
   114  		EventService: &mock.EventService{
   115  			SubscribeFn: func(id string) ots.Subscription {
   116  				return &sub
   117  			},
   118  		},
   119  		Logger: logr.Discard(),
   120  	}
   121  
   122  	go spooler.Start(context.Background())
   123  
   124  	// send event
   125  	sub.c <- ots.Event{Type: ots.RunCanceled, Payload: want}
   126  
   127  	assert.Equal(t, want, <-spooler.GetCancelation())
   128  }