utils_ortb_test.go

package utils

import (
	"github.com/go-test/deep"
	"github.com/mxmCherry/openrtb"
	"reflect"
	"testing"
)

//Constants

var string_array_a = []string{"a", "b", "c"}
var string_array_b []string
var string_array_fusion = []string{"a", "b", "c"}

var data_array_a = []openrtb.Data{openrtb.Data{}}
var data_array_b = []openrtb.Data{}
var data_array_fusion = []openrtb.Data{openrtb.Data{}}

var producer_a = &openrtb.Producer{
	ID:     "id",
	Name:   "name",
	Cat:    string_array_a,
	Domain: "",
	Ext:    nil,
}

var producer_b = &openrtb.Producer{
	ID:     "",
	Name:   "",
	Cat:    string_array_b,
	Domain: "domain",
	Ext:    nil,
}

var producer_fusion = &openrtb.Producer{
	ID:     "id",
	Name:   "name",
	Cat:    string_array_fusion,
	Domain: "domain",
	Ext:    nil,
}

var publisher_a = &openrtb.Publisher{
	ID:     "id",
	Name:   "",
	Cat:    string_array_a,
	Domain: "",
	Ext:    nil,
}

var publisher_b = &openrtb.Publisher{
	ID:     "",
	Name:   "name",
	Cat:    string_array_b,
	Domain: "domain",
	Ext:    nil,
}

var publisher_fusion = &openrtb.Publisher{
	ID:     "id",
	Name:   "name",
	Cat:    string_array_fusion,
	Domain: "domain",
	Ext:    nil,
}

var content_a = &openrtb.Content{
	ID:                 "id",
	Episode:            1,
	Title:              "title",
	Series:             "series",
	Season:             "season",
	Artist:             "artist",
	Genre:              "genre",
	Album:              "album",
	ISRC:               "usrc",
	Producer:           producer_a,
	URL:                "",
	Cat:                string_array_a,
	ProdQ:              nil,
	VideoQuality:       nil,
	Context:            1,
	ContentRating:      "rating",
	UserRating:         "rating",
	QAGMediaRating:     1,
	Keywords:           "a, b, c",
	LiveStream:         1,
	SourceRelationship: 1,
	Len:                1,
	Language:           "lan",
	Embeddable:         1,
	Data:               data_array_a,
	Ext:                nil,
}

var content_b = &openrtb.Content{
	ID:                 "",
	Episode:            0,
	Title:              "",
	Series:             "",
	Season:             "",
	Artist:             "",
	Genre:              "",
	Album:              "",
	ISRC:               "",
	Producer:           producer_b,
	URL:                "",
	Cat:                string_array_b,
	ProdQ:              nil,
	VideoQuality:       nil,
	Context:            0,
	ContentRating:      "",
	UserRating:         "",
	QAGMediaRating:     0,
	Keywords:           "",
	LiveStream:         0,
	SourceRelationship: 0,
	Len:                0,
	Language:           "",
	Embeddable:         0,
	Data:               data_array_b,
	Ext:                nil,
}

var content_fusion = &openrtb.Content{
	ID:                 "id",
	Episode:            1,
	Title:              "title",
	Series:             "series",
	Season:             "season",
	Artist:             "artist",
	Genre:              "genre",
	Album:              "album",
	ISRC:               "usrc",
	Producer:           producer_fusion,
	URL:                "",
	Cat:                string_array_fusion,
	ProdQ:              nil,
	VideoQuality:       nil,
	Context:            1,
	ContentRating:      "rating",
	UserRating:         "rating",
	QAGMediaRating:     1,
	Keywords:           "a, b, c",
	LiveStream:         1,
	SourceRelationship: 1,
	Len:                1,
	Language:           "lan",
	Embeddable:         1,
	Data:               data_array_fusion,
	Ext:                nil,
}

var site_a = &openrtb.Site{
	ID:            "id",
	Name:          "name",
	Domain:        "",
	Cat:           string_array_a,
	SectionCat:    string_array_a,
	PageCat:       string_array_a,
	Page:          "",
	Ref:           "",
	Search:        "",
	Mobile:        0,
	PrivacyPolicy: 10,
	Publisher:     publisher_a,
	Content:       content_a,
	Keywords:      "a, b, c",
	Ext:           nil,
}

var site_b = &openrtb.Site{
	ID:            "",
	Name:          "",
	Domain:        "domain",
	Cat:           string_array_b,
	SectionCat:    string_array_b,
	PageCat:       string_array_b,
	Page:          "page",
	Ref:           "ref",
	Search:        "search",
	Mobile:        10,
	PrivacyPolicy: 0,
	Publisher:     publisher_b,
	Content:       content_b,
	Keywords:      "",
	Ext:           nil,
}

var site_fusion = &openrtb.Site{
	ID:            "id",
	Name:          "name",
	Domain:        "domain",
	Cat:           string_array_fusion,
	SectionCat:    string_array_fusion,
	PageCat:       string_array_fusion,
	Page:          "page",
	Ref:           "ref",
	Search:        "search",
	Mobile:        10,
	PrivacyPolicy: 10,
	Publisher:     publisher_fusion,
	Content:       content_fusion,
	Keywords:      "a, b, c",
	Ext:           nil,
}

var imp_array_a = []openrtb.Imp{
	openrtb.Imp{},
	openrtb.Imp{},
}

var imp_array_b = []openrtb.Imp{
	openrtb.Imp{},
}

var imp_array_fusion = []openrtb.Imp{
	openrtb.Imp{},
	openrtb.Imp{},
}

var app_a = &openrtb.App{
	ID:            "id",
	Name:          "name",
	Bundle:        "bundle",
	Domain:        "domain",
	StoreURL:      "url",
	Cat:           string_array_a,
	SectionCat:    string_array_a,
	PageCat:       string_array_a,
	Ver:           "ver",
	PrivacyPolicy: 10,
	Paid:          10,
	Publisher:     publisher_a,
	Content:       content_a,
	Keywords:      "a, b ,c",
	Ext:           nil,
}

var app_b = &openrtb.App{
	ID:            "",
	Name:          "",
	Bundle:        "",
	Domain:        "",
	StoreURL:      "",
	Cat:           string_array_b,
	SectionCat:    string_array_b,
	PageCat:       string_array_b,
	Ver:           "",
	PrivacyPolicy: 0,
	Paid:          0,
	Publisher:     publisher_b,
	Content:       content_b,
	Keywords:      "",
	Ext:           nil,
}

var app_fusion = &openrtb.App{
	ID:            "id",
	Name:          "name",
	Bundle:        "bundle",
	Domain:        "domain",
	StoreURL:      "url",
	Cat:           string_array_fusion,
	SectionCat:    string_array_fusion,
	PageCat:       string_array_fusion,
	Ver:           "ver",
	PrivacyPolicy: 10,
	Paid:          10,
	Publisher:     publisher_fusion,
	Content:       content_fusion,
	Keywords:      "a, b ,c",
	Ext:           nil,
}

var geo_a = &openrtb.Geo{
	Lat:           10,
	Lon:           10,
	Type:          10,
	Accuracy:      10,
	LastFix:       10,
	IPService:     10,
	Country:       "country",
	Region:        "region",
	RegionFIPS104: "fip",
	Metro:         "metro",
	City:          "city",
	ZIP:           "zip",
	UTCOffset:     10,
	Ext:           nil,
}

var geo_b = &openrtb.Geo{
	Lat:           0,
	Lon:           0,
	Type:          0,
	Accuracy:      0,
	LastFix:       0,
	IPService:     0,
	Country:       "",
	Region:        "",
	RegionFIPS104: "",
	Metro:         "",
	City:          "",
	ZIP:           "",
	UTCOffset:     0,
	Ext:           nil,
}

var geo_fusion = &openrtb.Geo{
	Lat:           10,
	Lon:           10,
	Type:          10,
	Accuracy:      10,
	LastFix:       10,
	IPService:     10,
	Country:       "country",
	Region:        "region",
	RegionFIPS104: "fip",
	Metro:         "metro",
	City:          "city",
	ZIP:           "zip",
	UTCOffset:     10,
	Ext:           nil,
}

var device_a = &openrtb.Device{
	UA:             "ua",
	Geo:            geo_a,
	DNT:            10,
	Lmt:            10,
	IP:             "ip",
	IPv6:           "ipv6",
	DeviceType:     0,
	Make:           "make",
	Model:          "model",
	OS:             "os",
	OSV:            "osv",
	HWV:            "hmw",
	H:              10,
	W:              10,
	PPI:            10,
	PxRatio:        10,
	JS:             10,
	GeoFetch:       10,
	FlashVer:       "fver",
	Language:       "lang",
	Carrier:        "car",
	MCCMNC:         "mc",
	ConnectionType: nil,
	IFA:            "ifa",
	DIDSHA1:        "did",
	DIDMD5:         "didm",
	DPIDSHA1:       "dpi",
	DPIDMD5:        "dpim",
	MACSHA1:        "mac",
	MACMD5:         "macm",
	Ext:            nil,
}

var device_b = &openrtb.Device{
	UA:             "",
	Geo:            nil,
	DNT:            0,
	Lmt:            0,
	IP:             "",
	IPv6:           "",
	DeviceType:     0,
	Make:           "",
	Model:          "",
	OS:             "",
	OSV:            "",
	HWV:            "",
	H:              0,
	W:              0,
	PPI:            0,
	PxRatio:        0,
	JS:             0,
	GeoFetch:       0,
	FlashVer:       "",
	Language:       "",
	Carrier:        "",
	MCCMNC:         "",
	ConnectionType: nil,
	IFA:            "",
	DIDSHA1:        "",
	DIDMD5:         "",
	DPIDSHA1:       "",
	DPIDMD5:        "",
	MACSHA1:        "",
	MACMD5:         "",
	Ext:            nil,
}

var device_fusion = &openrtb.Device{
	UA:             "ua",
	Geo:            geo_a,
	DNT:            10,
	Lmt:            10,
	IP:             "ip",
	IPv6:           "ipv6",
	DeviceType:     0,
	Make:           "make",
	Model:          "model",
	OS:             "os",
	OSV:            "osv",
	HWV:            "hmw",
	H:              10,
	W:              10,
	PPI:            10,
	PxRatio:        10,
	JS:             10,
	GeoFetch:       10,
	FlashVer:       "fver",
	Language:       "lang",
	Carrier:        "car",
	MCCMNC:         "mc",
	ConnectionType: nil,
	IFA:            "ifa",
	DIDSHA1:        "did",
	DIDMD5:         "didm",
	DPIDSHA1:       "dpi",
	DPIDMD5:        "dpim",
	MACSHA1:        "mac",
	MACMD5:         "macm",
	Ext:            nil,
}

var user_a = &openrtb.User{
	ID:         "id",
	BuyerUID:   "buyerid",
	Yob:        10,
	Gender:     "gender",
	Keywords:   "a, b, c",
	CustomData: "custom",
	Geo:        geo_a,
	Data:       data_array_a,
	Ext:        nil,
}

// TESTS

func TestMergeStringArray(t *testing.T) {
	type args struct {
		a []string
		b []string
	}
	tests := []struct {
		name string
		args args
		want []string
	}{
		{
			name: "normal",
			args: args{
				a: string_array_a,
				b: string_array_b,
			},
			want: string_array_fusion,
		},
		{
			name: "empty",
			args: args{
				a: []string{"a", "b", "c"},
				b: []string{},
			},
			want: []string{"a", "b", "c"},
		},
		{
			name: "only duplicates",
			args: args{
				a: []string{"a", "b", "c"},
				b: []string{"a", "b", "c"},
			},
			want: []string{"a", "b", "c"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeStringArray(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeStringArray() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeString(t *testing.T) {
	type args struct {
		a string
		b string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		{
			"a is empty",
			args{
				"", "not empty",
			},
			"not empty",
		},
		{
			"b is empty",
			args{
				"not empty", "",
			},
			"not empty",
		},
		{
			"both are empty",
			args{
				"", "",
			},
			"",
		},
		{
			"both are not empty",
			args{
				"a", "b",
			},
			"a",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeString(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("MergeString() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeInt8(t *testing.T) {
	type args struct {
		a int8
		b int8
	}
	tests := []struct {
		name string
		args args
		want int8
	}{
		{
			"a > b",
			args{
				1, 0,
			},
			1,
		},
		{
			"a < b",
			args{
				1, 2,
			},
			2,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeInt8(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("MergeInt8() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergePublisher(t *testing.T) {
	type args struct {
		a *openrtb.Publisher
		b *openrtb.Publisher
	}

	tests := []struct {
		name string
		args args
		want *openrtb.Publisher
	}{
		{
			"a is nil",
			args{
				nil,
				nil,
			},
			nil,
		},
		{
			"standard",
			args{
				publisher_a,
				publisher_b,
			},
			publisher_fusion,
		},
		{
			"standard reverse",
			args{
				publisher_b,
				publisher_a,
			},
			publisher_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergePublisher(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergePublisher() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeProducer(t *testing.T) {
	type args struct {
		a *openrtb.Producer
		b *openrtb.Producer
	}
	tests := []struct {
		name string
		args args
		want *openrtb.Producer
	}{
		{
			"both are nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: producer_a,
				b: producer_b,
			},
			producer_fusion,
		},
		{
			"standard reversed",
			args{
				a: producer_b,
				b: producer_a,
			},
			producer_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeProducer(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeProducer() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeProductionQuality(t *testing.T) {

	b := openrtb.ProductionQualityUserGenerated.Ptr()

	type args struct {
		a *openrtb.ProductionQuality
		b *openrtb.ProductionQuality
	}
	tests := []struct {
		name string
		args args
		want *openrtb.ProductionQuality
	}{
		{
			"both are nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: openrtb.ProductionQualityProfessionallyProduced.Ptr(),
				b: b,
			},
			b,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeProductionQuality(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeProductionQuality() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeDataArray(t *testing.T) {
	type args struct {
		a []openrtb.Data
		b []openrtb.Data
	}
	tests := []struct {
		name string
		args args
		want []openrtb.Data
	}{
		{
			"a > b",
			args{
				a: []openrtb.Data{openrtb.Data{}},
				b: []openrtb.Data{},
			},
			[]openrtb.Data{openrtb.Data{}},
		},
		{
			"a < b",
			args{
				a: []openrtb.Data{},
				b: []openrtb.Data{openrtb.Data{}},
			},
			[]openrtb.Data{openrtb.Data{}},
		},
		{
			"empty",
			args{
				a: []openrtb.Data{},
				b: []openrtb.Data{},
			},
			[]openrtb.Data{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeDataArray(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeDataArray() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeContent(t *testing.T) {
	type args struct {
		a *openrtb.Content
		b *openrtb.Content
	}
	tests := []struct {
		name string
		args args
		want *openrtb.Content
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard", // ERROR WE GOT PRODUCER DOMAIN AS NULL
			args{
				a: content_b,
				b: content_a,
			},
			content_fusion,
		},
		{
			"standard reversed",
			args{
				a: content_a,
				b: content_b,
			},
			content_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := MergeContent(tt.args.a, tt.args.b)
			if diff := deep.Equal(got, tt.want); diff != nil {
				t.Error(diff)
			}
		})
	}
}

func TestMergeSite(t *testing.T) {
	type args struct {
		a *openrtb.Site
		b *openrtb.Site
	}
	tests := []struct {
		name string
		args args
		want *openrtb.Site
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: site_a,
				b: site_b,
			},
			site_fusion,
		},
		{
			"standard reverse",
			args{
				a: site_b,
				b: site_a,
			},
			site_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeSite(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeSite() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeImpArray(t *testing.T) {
	type args struct {
		a []openrtb.Imp
		b []openrtb.Imp
	}
	tests := []struct {
		name string
		args args
		want []openrtb.Imp
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: imp_array_a,
				b: imp_array_b,
			},
			imp_array_fusion,
		},
		{
			"standard reverse",
			args{
				a: imp_array_b,
				b: imp_array_a,
			},
			imp_array_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeImpArray(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeImpArray() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeApp(t *testing.T) {
	type args struct {
		a *openrtb.App
		b *openrtb.App
	}
	tests := []struct {
		name string
		args args
		want *openrtb.App
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: app_a,
				b: app_b,
			},
			app_fusion,
		},
		{
			"standard reverse",
			args{
				a: app_b,
				b: app_a,
			},
			app_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeApp(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeApp() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeGeo(t *testing.T) {
	type args struct {
		a *openrtb.Geo
		b *openrtb.Geo
	}
	tests := []struct {
		name string
		args args
		want *openrtb.Geo
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: geo_a,
				b: geo_b,
			},
			geo_fusion,
		},
		{
			"standard reverse",
			args{
				a: geo_b,
				b: geo_a,
			},
			geo_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeGeo(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeGeo() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeDevice(t *testing.T) {
	type args struct {
		a *openrtb.Device
		b *openrtb.Device
	}
	tests := []struct {
		name string
		args args
		want *openrtb.Device
	}{
		{
			"nil",
			args{
				a: nil,
				b: nil,
			},
			nil,
		},
		{
			"standard",
			args{
				a: device_a,
				b: device_b,
			},
			device_fusion,
		},
		{
			"standard reverse",
			args{
				a: device_b,
				b: device_a,
			},
			device_fusion,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeDevice(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeDevice() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMergeUser(t *testing.T) {
	type args struct {
		a *openrtb.User
		b *openrtb.User
	}
	tests := []struct {
		name string
		args args
		want *openrtb.User
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MergeUser(tt.args.a, tt.args.b); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MergeUser() = %v, want %v", got, tt.want)
			}
		})
	}
}