routing_test.go

package service

import (
	"context"
	"reflect"
	"testing"

	"code.fbi.h-da.de/danet/costaquanta/ctrl/internal/core/model"
	"go.opentelemetry.io/otel/trace"
	"go.opentelemetry.io/otel/trace/noop"
	"go.uber.org/zap"
)

func TestNewRouting(t *testing.T) {
	t.Parallel()

	type args struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	tests := []struct {
		name string
		args args
		want *Routing
	}{
		{
			name: "test",
			args: args{
				logger: zap.NewNop().Sugar(),
				tracer: noop.NewTracerProvider().Tracer("test"),
			},
			want: &Routing{
				logger: zap.NewNop().Sugar(),
				tracer: noop.NewTracerProvider().Tracer("test"),
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			if got := NewRoutingService(tt.args.logger, tt.args.tracer); !reflect.DeepEqual(
				got,
				tt.want,
			) {
				t.Errorf("NewRouting() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRouting_RequestRoute(t *testing.T) {
	t.Parallel()

	type fields struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	type args struct {
		ctx context.Context
		req RequestRouteDTO
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    model.Route
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &Routing{
				logger: tt.fields.logger,
				tracer: tt.fields.tracer,
			}
			got, err := r.RequestRoute(tt.args.ctx, tt.args.req)
			if (err != nil) != tt.wantErr {
				t.Errorf("Routing.RequestRoute() error = %v, wantErr %v", err, tt.wantErr)

				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Routing.RequestRoute() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRouting_AnnouncePayloadRelay(t *testing.T) {
	t.Parallel()

	type fields struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	type args struct {
		ctx context.Context
		req AnnouncePayloadRelayRequestDTO
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &Routing{
				logger: tt.fields.logger,
				tracer: tt.fields.tracer,
			}
			if err := r.AnnouncePayloadRelay(tt.args.ctx, tt.args.req); (err != nil) != tt.wantErr {
				t.Errorf("Routing.AnnouncePayloadRelay() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestRouting_PayloadRelayFinished(t *testing.T) {
	t.Parallel()

	type fields struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	type args struct {
		ctx context.Context
		req PayloadRelayFinishedRequestDTO
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &Routing{
				logger: tt.fields.logger,
				tracer: tt.fields.tracer,
			}
			if err := r.PayloadRelayFinished(tt.args.ctx, tt.args.req); (err != nil) != tt.wantErr {
				t.Errorf("Routing.PayloadRelayFinished() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestRouting_PayloadRelayError(t *testing.T) {
	t.Parallel()

	type fields struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	type args struct {
		ctx context.Context
		req PayloadRelayErrorDTO
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &Routing{
				logger: tt.fields.logger,
				tracer: tt.fields.tracer,
			}
			if err := r.PayloadRelayError(tt.args.ctx, tt.args.req); (err != nil) != tt.wantErr {
				t.Errorf("Routing.PayloadRelayError() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestRouting_PushKeyStoreFillLevel(t *testing.T) {
	t.Parallel()

	type fields struct {
		logger *zap.SugaredLogger
		tracer trace.Tracer
	}
	type args struct {
		ctx context.Context
		req PushKeyStoreFillLevelRequestDTO
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			r := &Routing{
				logger: tt.fields.logger,
				tracer: tt.fields.tracer,
			}
			if err := r.PushKeyStoreFillLevel(tt.args.ctx, tt.args.req); (err != nil) != tt.wantErr {
				t.Errorf("Routing.PushKeyStoreFillLevel() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}