pnd_test.go

package api

import (
	"reflect"
	"testing"

	ppb "code.fbi.h-da.de/danet/api/go/gosdn/pnd"
	tpb "code.fbi.h-da.de/danet/api/go/gosdn/transport"
	"code.fbi.h-da.de/danet/gosdn/interfaces/change"
	"code.fbi.h-da.de/danet/gosdn/interfaces/device"
	"code.fbi.h-da.de/danet/gosdn/interfaces/networkdomain"
	"code.fbi.h-da.de/danet/gosdn/interfaces/southbound"
	"code.fbi.h-da.de/danet/gosdn/interfaces/store"
	"github.com/google/uuid"
)

func TestNewAdapter(t *testing.T) {
	type args struct {
		id       string
		endpoint string
	}
	tests := []struct {
		name    string
		args    args
		want    networkdomain.NetworkDomain
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := NewAdapter(tt.args.id, tt.args.endpoint)
			if (err != nil) != tt.wantErr {
				t.Errorf("NewAdapter() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewAdapter() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_Destroy(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name    string
		fields  fields
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.Destroy(); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.Destroy() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_AddSbi(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		s southbound.SouthboundInterface
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.AddSbi(tt.args.s); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.AddSbi() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_RemoveSbi(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		in0 uuid.UUID
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.RemoveSbi(tt.args.in0); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.RemoveSbi() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_AddDevice(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		name string
		opts *tpb.TransportOption
		sid  uuid.UUID
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.AddDevice(tt.args.name, tt.args.opts, tt.args.sid); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.AddDevice() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_GetDevice(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		identifier string
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    device.Device
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			got, err := p.GetDevice(tt.args.identifier)
			if (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.GetDevice() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.GetDevice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_RemoveDevice(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		did uuid.UUID
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.RemoveDevice(tt.args.did); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.RemoveDevice() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_Devices(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   []uuid.UUID
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.Devices(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.Devices() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_ChangeOND(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		uuid      uuid.UUID
		operation ppb.ApiOperation
		path      string
		value     []string
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			_, err := p.ChangeOND(tt.args.uuid, tt.args.operation, tt.args.path, tt.args.value...)
			if (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.ChangeOND() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_Request(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		did  uuid.UUID
		path string
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			_, err := p.Request(tt.args.did, tt.args.path)
			if (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.Request() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_RequestAll(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		in0 string
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.RequestAll(tt.args.in0); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.RequestAll() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_GetName(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.GetName(); got != tt.want {
				t.Errorf("PrincipalNetworkDomainAdapter.GetName() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_GetDescription(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   string
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.GetDescription(); got != tt.want {
				t.Errorf("PrincipalNetworkDomainAdapter.GetDescription() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_MarshalDevice(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		in0 string
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    string
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			got, err := p.MarshalDevice(tt.args.in0)
			if (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.MarshalDevice() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("PrincipalNetworkDomainAdapter.MarshalDevice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_ContainsDevice(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		in0 uuid.UUID
	}
	tests := []struct {
		name   string
		fields fields
		args   args
		want   bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.ContainsDevice(tt.args.in0); got != tt.want {
				t.Errorf("PrincipalNetworkDomainAdapter.ContainsDevice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_GetSBIs(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   store.Store
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.GetSBIs(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.GetSBIs() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_ID(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   uuid.UUID
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.ID(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.ID() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_PendingChanges(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   []uuid.UUID
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.PendingChanges(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.PendingChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_CommittedChanges(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	tests := []struct {
		name   string
		fields fields
		want   []uuid.UUID
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if got := p.CommittedChanges(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.CommittedChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_GetChange(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		in uuid.UUID
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    change.Change
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			got, err := p.GetChange(tt.args.in)
			if (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.GetChange() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("PrincipalNetworkDomainAdapter.GetChange() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_Commit(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		cuid uuid.UUID
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.Commit(tt.args.cuid); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.Commit() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestPrincipalNetworkDomainAdapter_Confirm(t *testing.T) {
	type fields struct {
		id       uuid.UUID
		endpoint string
	}
	type args struct {
		cuid uuid.UUID
	}
	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) {
			p := &PrincipalNetworkDomainAdapter{
				id:       tt.fields.id,
				endpoint: tt.fields.endpoint,
			}
			if err := p.Confirm(tt.args.cuid); (err != nil) != tt.wantErr {
				t.Errorf("PrincipalNetworkDomainAdapter.Confirm() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func Test_filterChanges(t *testing.T) {
	type args struct {
		state ppb.Change_State
		resp  *ppb.GetResponse
	}
	tests := []struct {
		name string
		args args
		want []uuid.UUID
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := filterChanges(tt.args.state, tt.args.resp); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("filterChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}