345 lines
8.6 KiB
Go
345 lines
8.6 KiB
Go
package lib
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
)
|
|
|
|
func TestOrgDataJSONMarshal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
orgData OrgData
|
|
}{
|
|
{
|
|
name: "single domain",
|
|
orgData: OrgData{
|
|
Name: "Kaseya Corp",
|
|
Domains: []string{"kaseya.com"},
|
|
Role: "seller",
|
|
Website: "https://kaseya.com",
|
|
Description: "IT management software company",
|
|
ContactName: "Fred Voccola",
|
|
ContactEmail: "fred@kaseya.com",
|
|
},
|
|
},
|
|
{
|
|
name: "multi domain",
|
|
orgData: OrgData{
|
|
Name: "Datto Holdings",
|
|
Domains: []string{"kaseya.com", "datto.com", "unitrends.com"},
|
|
Role: "buyer",
|
|
},
|
|
},
|
|
{
|
|
name: "minimal",
|
|
orgData: OrgData{
|
|
Name: "Test Org",
|
|
Domains: []string{"test.com"},
|
|
},
|
|
},
|
|
{
|
|
name: "ib role",
|
|
orgData: OrgData{
|
|
Name: "Goldman Sachs",
|
|
Domains: []string{"gs.com", "goldmansachs.com"},
|
|
Role: "ib",
|
|
},
|
|
},
|
|
{
|
|
name: "advisor role",
|
|
orgData: OrgData{
|
|
Name: "Deloitte",
|
|
Domains: []string{"deloitte.com"},
|
|
Role: "advisor",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
// Marshal
|
|
data, err := json.Marshal(tc.orgData)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
|
|
// Unmarshal
|
|
var got OrgData
|
|
if err := json.Unmarshal(data, &got); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
|
|
// Verify fields
|
|
if got.Name != tc.orgData.Name {
|
|
t.Errorf("Name: got %q, want %q", got.Name, tc.orgData.Name)
|
|
}
|
|
if len(got.Domains) != len(tc.orgData.Domains) {
|
|
t.Errorf("Domains length: got %d, want %d", len(got.Domains), len(tc.orgData.Domains))
|
|
}
|
|
for i, d := range tc.orgData.Domains {
|
|
if got.Domains[i] != d {
|
|
t.Errorf("Domains[%d]: got %q, want %q", i, got.Domains[i], d)
|
|
}
|
|
}
|
|
if got.Role != tc.orgData.Role {
|
|
t.Errorf("Role: got %q, want %q", got.Role, tc.orgData.Role)
|
|
}
|
|
if got.Website != tc.orgData.Website {
|
|
t.Errorf("Website: got %q, want %q", got.Website, tc.orgData.Website)
|
|
}
|
|
if got.Description != tc.orgData.Description {
|
|
t.Errorf("Description: got %q, want %q", got.Description, tc.orgData.Description)
|
|
}
|
|
if got.ContactName != tc.orgData.ContactName {
|
|
t.Errorf("ContactName: got %q, want %q", got.ContactName, tc.orgData.ContactName)
|
|
}
|
|
if got.ContactEmail != tc.orgData.ContactEmail {
|
|
t.Errorf("ContactEmail: got %q, want %q", got.ContactEmail, tc.orgData.ContactEmail)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOrgDataJSONOmitEmpty(t *testing.T) {
|
|
// Verify omitempty works for optional fields
|
|
orgData := OrgData{
|
|
Name: "Minimal Org",
|
|
Domains: []string{"minimal.com"},
|
|
}
|
|
|
|
data, err := json.Marshal(orgData)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
|
|
// Parse as map to check field presence
|
|
var m map[string]interface{}
|
|
if err := json.Unmarshal(data, &m); err != nil {
|
|
t.Fatalf("Unmarshal to map failed: %v", err)
|
|
}
|
|
|
|
// Required fields should be present
|
|
if _, ok := m["name"]; !ok {
|
|
t.Error("name should be present")
|
|
}
|
|
if _, ok := m["domains"]; !ok {
|
|
t.Error("domains should be present")
|
|
}
|
|
|
|
// Optional fields with zero values should be omitted
|
|
if v, ok := m["website"]; ok && v != "" {
|
|
t.Error("website should be omitted when empty")
|
|
}
|
|
if v, ok := m["description"]; ok && v != "" {
|
|
t.Error("description should be omitted when empty")
|
|
}
|
|
}
|
|
|
|
func TestDealOrgDataJSONMarshal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
dealOrgData DealOrgData
|
|
}{
|
|
{
|
|
name: "seller with domain lock",
|
|
dealOrgData: DealOrgData{
|
|
OrgID: "org-123",
|
|
Role: "seller",
|
|
DomainLock: true,
|
|
},
|
|
},
|
|
{
|
|
name: "buyer without domain lock",
|
|
dealOrgData: DealOrgData{
|
|
OrgID: "org-456",
|
|
Role: "buyer",
|
|
DomainLock: false,
|
|
},
|
|
},
|
|
{
|
|
name: "ib role",
|
|
dealOrgData: DealOrgData{
|
|
OrgID: "org-789",
|
|
Role: "ib",
|
|
DomainLock: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
data, err := json.Marshal(tc.dealOrgData)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
|
|
var got DealOrgData
|
|
if err := json.Unmarshal(data, &got); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
|
|
if got.OrgID != tc.dealOrgData.OrgID {
|
|
t.Errorf("OrgID: got %q, want %q", got.OrgID, tc.dealOrgData.OrgID)
|
|
}
|
|
if got.Role != tc.dealOrgData.Role {
|
|
t.Errorf("Role: got %q, want %q", got.Role, tc.dealOrgData.Role)
|
|
}
|
|
if got.DomainLock != tc.dealOrgData.DomainLock {
|
|
t.Errorf("DomainLock: got %v, want %v", got.DomainLock, tc.dealOrgData.DomainLock)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRequestDataJSONMarshal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
req RequestData
|
|
}{
|
|
{
|
|
name: "full request",
|
|
req: RequestData{
|
|
Title: "Provide audited financial statements for the last 3 years",
|
|
ItemNumber: "1.3",
|
|
Section: "Financial",
|
|
Description: "Please provide audited P&L, balance sheet, and cash flow statements for FY2023, FY2024, FY2025.",
|
|
Priority: "high",
|
|
Status: "open",
|
|
AssigneeID: "user-123",
|
|
AssigneeName: "John Smith",
|
|
DueDate: "2026-03-15",
|
|
BuyerComment: "Need by end of week",
|
|
SellerComment: "Working on it",
|
|
Tags: []string{"financial", "urgent", "audit"},
|
|
LinkedEntryIDs: []string{"entry-1", "entry-2"},
|
|
},
|
|
},
|
|
{
|
|
name: "minimal request",
|
|
req: RequestData{
|
|
Title: "Basic info request",
|
|
ItemNumber: "A-1",
|
|
Section: "General",
|
|
Priority: "medium",
|
|
Status: "open",
|
|
},
|
|
},
|
|
{
|
|
name: "answered request",
|
|
req: RequestData{
|
|
Title: "Revenue breakdown by geography",
|
|
ItemNumber: "2.1",
|
|
Section: "Sales",
|
|
Description: "Provide revenue split by region (NA, EMEA, APAC)",
|
|
Priority: "low",
|
|
Status: "answered",
|
|
LinkedEntryIDs: []string{"answer-123"},
|
|
},
|
|
},
|
|
{
|
|
name: "not applicable",
|
|
req: RequestData{
|
|
Title: "Union contracts",
|
|
ItemNumber: "5.2",
|
|
Section: "HR",
|
|
Description: "Provide all union agreements",
|
|
Priority: "low",
|
|
Status: "not_applicable",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
data, err := json.Marshal(tc.req)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
|
|
var got RequestData
|
|
if err := json.Unmarshal(data, &got); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
|
|
if got.Title != tc.req.Title {
|
|
t.Errorf("Title: got %q, want %q", got.Title, tc.req.Title)
|
|
}
|
|
if got.ItemNumber != tc.req.ItemNumber {
|
|
t.Errorf("ItemNumber: got %q, want %q", got.ItemNumber, tc.req.ItemNumber)
|
|
}
|
|
if got.Section != tc.req.Section {
|
|
t.Errorf("Section: got %q, want %q", got.Section, tc.req.Section)
|
|
}
|
|
if got.Priority != tc.req.Priority {
|
|
t.Errorf("Priority: got %q, want %q", got.Priority, tc.req.Priority)
|
|
}
|
|
if got.Status != tc.req.Status {
|
|
t.Errorf("Status: got %q, want %q", got.Status, tc.req.Status)
|
|
}
|
|
if len(got.Tags) != len(tc.req.Tags) {
|
|
t.Errorf("Tags length: got %d, want %d", len(got.Tags), len(tc.req.Tags))
|
|
}
|
|
if len(got.LinkedEntryIDs) != len(tc.req.LinkedEntryIDs) {
|
|
t.Errorf("LinkedEntryIDs length: got %d, want %d", len(got.LinkedEntryIDs), len(tc.req.LinkedEntryIDs))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorkstreamDataJSONMarshal(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
ws WorkstreamData
|
|
}{
|
|
{
|
|
name: "with description",
|
|
ws: WorkstreamData{
|
|
Name: "Financial Due Diligence",
|
|
Description: "All financial information requests",
|
|
},
|
|
},
|
|
{
|
|
name: "minimal",
|
|
ws: WorkstreamData{
|
|
Name: "Legal",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
data, err := json.Marshal(tc.ws)
|
|
if err != nil {
|
|
t.Fatalf("Marshal failed: %v", err)
|
|
}
|
|
|
|
var got WorkstreamData
|
|
if err := json.Unmarshal(data, &got); err != nil {
|
|
t.Fatalf("Unmarshal failed: %v", err)
|
|
}
|
|
|
|
if got.Name != tc.ws.Name {
|
|
t.Errorf("Name: got %q, want %q", got.Name, tc.ws.Name)
|
|
}
|
|
if got.Description != tc.ws.Description {
|
|
t.Errorf("Description: got %q, want %q", got.Description, tc.ws.Description)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRoleHierarchyContainsSuperAdmin(t *testing.T) {
|
|
// Verify super_admin is in the hierarchy and has the highest level
|
|
saLevel, ok := RoleHierarchy[RoleSuperAdmin]
|
|
if !ok {
|
|
t.Fatal("super_admin should be in RoleHierarchy")
|
|
}
|
|
|
|
// super_admin should be higher than all other roles
|
|
for role, level := range RoleHierarchy {
|
|
if role != RoleSuperAdmin && level >= saLevel {
|
|
t.Errorf("super_admin (%d) should be higher than %s (%d)", saLevel, role, level)
|
|
}
|
|
}
|
|
}
|