module Rezoom.SQL.Test.Blueprints

open NUnit.Framework

open Rezoom.SQL.Mapping

open Rezoom.SQL.Mapping.CodeGeneration

open System

let ofType (ty) =

Rezoom.SQL.Mapping.Blueprint.ofType UserTypeLibrary.Empty ty

type Folder =

{

Id : int

ParentFolder : Folder

ChildFolders : Folder list

}

let ``folder blueprint makes sense`` () =

let blue = Blueprint.ofType typeof<Folder>

match blue.Cardinality with

| One { Shape = Composite folder } ->

match folder.Columns.["ParentFolder"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for parent folder"

| Some childFolders ->

Assert.That("ChildFolders".Equals(childFolders.Name, StringComparison.OrdinalIgnoreCase))

Assert.That(obj.ReferenceEquals(childFolders, folder.Columns.["ChildFolders"]))

match folder.Columns.["ChildFolders"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for child folders"

| Some parent ->

Assert.That("ParentFolder".Equals(parent.Name, StringComparison.OrdinalIgnoreCase))

| _ -> failwith "Wrong cardinality/shape"

type UserFriendMap =

{

Friend1 : User

Friend2 : User

}

and User =

{

Id : int

Friend1Maps : UserFriendMap list

Friend2Maps : UserFriendMap list

}

let ``user blueprint makes sense`` () =

let blue = Blueprint.ofType typeof<User>

match blue.Cardinality with

| One { Shape = Composite user } ->

match user.Columns.["Friend1Maps"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for friend1maps"

| Some friend1Maps ->

Assert.That("Friend1".Equals(friend1Maps.Name, StringComparison.OrdinalIgnoreCase))

match user.Columns.["Friend2Maps"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for friend2maps"

| Some friend2Maps ->

Assert.That("Friend2".Equals(friend2Maps.Name, StringComparison.OrdinalIgnoreCase))

| _ -> failwith "Wrong cardinality/shape"

let ``friend map blueprint makes sense`` () =

let blue = Blueprint.ofType typeof<UserFriendMap>

match blue.Cardinality with

| One { Shape = Composite friendMap } ->

match friendMap.Columns.["Friend1"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for friend1"

| Some friend1Maps ->

Assert.That("Friend1Maps".Equals(friend1Maps.Name, StringComparison.OrdinalIgnoreCase))

match friendMap.Columns.["Friend2"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for friend1"

| Some friend2Maps ->

Assert.That("Friend2Maps".Equals(friend2Maps.Name, StringComparison.OrdinalIgnoreCase))

| _ -> failwith "Wrong cardinality/shape"

type Foo =

{

FooId : int

ChildBars : Bar array

}

and Bar =

{

BarId : int

ParentFoo : Foo

}

let ``foo blueprint makes sense`` () =

let blue = Blueprint.ofType typeof<Foo>

match blue.Cardinality with

| One { Shape = Composite fooMap } ->

match fooMap.Columns.["ChildBars"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for ChildBars"

| Some parentFoo ->

Assert.That("ParentFoo".Equals(parentFoo.Name, StringComparison.OrdinalIgnoreCase))

| _ -> failwith "Wrong cardinality/shape"

let ``bar blueprint makes sense`` () =

let blue = Blueprint.ofType typeof<Bar>

match blue.Cardinality with

| One { Shape = Composite barMap } ->

match barMap.Columns.["ParentFoo"].ReverseRelationship.Value with

| None -> failwith "No reverse relationship for ParentFoo"

| Some childBars ->

Assert.That("ChildBars".Equals(childBars.Name, StringComparison.OrdinalIgnoreCase))

| _ -> failwith "Wrong cardinality/shape"