github.com/goravel/framework@v1.13.9/queue/utils_test.go (about)

     1  package queue
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  
     8  	"github.com/goravel/framework/contracts/event"
     9  	queuecontract "github.com/goravel/framework/contracts/queue"
    10  )
    11  
    12  type TestJob struct {
    13  }
    14  
    15  func (receiver *TestJob) Signature() string {
    16  	return "TestName"
    17  }
    18  
    19  func (receiver *TestJob) Handle(args ...any) error {
    20  	return nil
    21  }
    22  
    23  type TestJobDuplicate struct {
    24  }
    25  
    26  func (receiver *TestJobDuplicate) Signature() string {
    27  	return "TestName"
    28  }
    29  
    30  func (receiver *TestJobDuplicate) Handle(args ...any) error {
    31  	return nil
    32  }
    33  
    34  type TestJobEmpty struct {
    35  }
    36  
    37  func (receiver *TestJobEmpty) Signature() string {
    38  	return ""
    39  }
    40  
    41  func (receiver *TestJobEmpty) Handle(args ...any) error {
    42  	return nil
    43  }
    44  
    45  func TestJobs2Tasks(t *testing.T) {
    46  	_, err := jobs2Tasks([]queuecontract.Job{
    47  		&TestJob{},
    48  	})
    49  
    50  	assert.Nil(t, err, "success")
    51  
    52  	_, err = jobs2Tasks([]queuecontract.Job{
    53  		&TestJob{},
    54  		&TestJobDuplicate{},
    55  	})
    56  
    57  	assert.NotNil(t, err, "Signature duplicate")
    58  
    59  	_, err = jobs2Tasks([]queuecontract.Job{
    60  		&TestJobEmpty{},
    61  	})
    62  
    63  	assert.NotNil(t, err, "Signature empty")
    64  }
    65  
    66  type TestEvent struct {
    67  }
    68  
    69  func (receiver *TestEvent) Signature() string {
    70  	return "TestName"
    71  }
    72  
    73  func (receiver *TestEvent) Handle(args []event.Arg) ([]event.Arg, error) {
    74  	return args, nil
    75  }
    76  
    77  type TestListener struct {
    78  }
    79  
    80  func (receiver *TestListener) Signature() string {
    81  	return "TestName"
    82  }
    83  
    84  func (receiver *TestListener) Queue(args ...any) event.Queue {
    85  	return event.Queue{
    86  		Enable:     false,
    87  		Connection: "",
    88  		Queue:      "",
    89  	}
    90  }
    91  
    92  func (receiver *TestListener) Handle(args ...any) error {
    93  	return nil
    94  }
    95  
    96  type TestListenerDuplicate struct {
    97  }
    98  
    99  func (receiver *TestListenerDuplicate) Signature() string {
   100  	return "TestName"
   101  }
   102  
   103  func (receiver *TestListenerDuplicate) Queue(args ...any) event.Queue {
   104  	return event.Queue{
   105  		Enable:     false,
   106  		Connection: "",
   107  		Queue:      "",
   108  	}
   109  }
   110  
   111  func (receiver *TestListenerDuplicate) Handle(args ...any) error {
   112  	return nil
   113  }
   114  
   115  type TestListenerEmpty struct {
   116  }
   117  
   118  func (receiver *TestListenerEmpty) Signature() string {
   119  	return ""
   120  }
   121  
   122  func (receiver *TestListenerEmpty) Queue(args ...any) event.Queue {
   123  	return event.Queue{
   124  		Enable:     false,
   125  		Connection: "",
   126  		Queue:      "",
   127  	}
   128  }
   129  
   130  func (receiver *TestListenerEmpty) Handle(args ...any) error {
   131  	return nil
   132  }
   133  
   134  func TestEvents2Tasks(t *testing.T) {
   135  	_, err := eventsToTasks(map[event.Event][]event.Listener{
   136  		&TestEvent{}: {
   137  			&TestListener{},
   138  		},
   139  	})
   140  	assert.Nil(t, err)
   141  
   142  	_, err = eventsToTasks(map[event.Event][]event.Listener{
   143  		&TestEvent{}: {
   144  			&TestListener{},
   145  			&TestListenerDuplicate{},
   146  		},
   147  	})
   148  	assert.Nil(t, err)
   149  
   150  	_, err = eventsToTasks(map[event.Event][]event.Listener{
   151  		&TestEvent{}: {
   152  			&TestListenerEmpty{},
   153  		},
   154  	})
   155  
   156  	assert.NotNil(t, err)
   157  }