func CreateProduct(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
product := &data.Product{
Name: "Product Name",
Price: data.Price{
Vat: 20,
Net: 100,
},
}
if err := tx.CreateProduct(product); err != nil {
t.Fatal("Failed to create product", err)
return
}
if product.ID < 1 {
t.Error("Expected ID of created product to be positive non-zero")
t.Fail()
}
}
func UpdateProduct(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
product := &data.Product{
Name: "Product Name",
Price: data.Price{
Vat: 20,
Net: 100,
},
}
if err := tx.CreateProduct(product); err != nil {
t.Fatal("Failed to create product", err)
return
}
product.Name = "Product Name Changed"
product.Price.Net = 200
if err := tx.UpdateProduct(product); err != nil {
t.Error("Failed to update product", err)
}
}
func RemoveOrderItem(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
product, order := testProductAndOrder(tx, 1)
item := &data.OrderItem{
Product: *product,
Quantity: 1,
}
if err := tx.CreateOrderItem(order.ID, item); err != nil {
t.Fatal("Failed to create order item", err)
return
}
if err := tx.RemoveOrderItem(order.ID, item.Product.ID); err != nil {
t.Error("Failed to remove order item", err)
}
}
func LoadOrderItem(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
product, order := testProductAndOrder(tx, 1)
item := &data.OrderItem{
Product: *product,
Quantity: 1,
}
if err := tx.CreateOrderItem(order.ID, item); err != nil {
t.Error("Failed to create order item", err)
return
}
loadedItem := &data.OrderItem{
Product: *product,
}
if err := tx.LoadOrderItem(order.ID, loadedItem); err != nil {
t.Error("Failed to load order item", err)
return
}
if !reflect.DeepEqual(item, loadedItem) {
t.Errorf("Loaded order item differs from created one:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(item), testutils.JSON(loadedItem))
}
}
func LoadOrder(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
order := &data.Order{
State: data.OrderStateDraft,
Time: uint64(time.Now().UTC().Unix()),
}
if err := tx.CreateOrder(order); err != nil {
t.Fatal("Failed to create order", err)
return
}
loadedOrder := &data.Order{
ID: order.ID,
}
if err := tx.LoadOrder(loadedOrder); err != nil {
t.Fatal("Failed to load order", err)
return
}
if !reflect.DeepEqual(order, loadedOrder) {
t.Errorf("Loaded order differs from created one:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(order), testutils.JSON(loadedOrder))
}
}
func CreateOrder(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
order := &data.Order{
State: data.OrderStateDraft,
Time: uint64(time.Now().UTC().Unix()),
}
if err := tx.CreateOrder(order); err != nil {
t.Fatal("Failed to create order", err)
return
}
if order.ID < 1 {
t.Error("Expected ID of created order to be positive non-zero")
t.Fail()
}
}
func UpdateOrder(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
order := &data.Order{
State: data.OrderStateDraft,
Time: uint64(time.Now().UTC().Unix()),
}
if err := tx.CreateOrder(order); err != nil {
t.Fatal("Failed to create order", err)
return
}
order.State = data.OrderStateCancelled
order.Time = uint64(time.Now().UTC().Unix())
if err := tx.UpdateOrder(order); err != nil {
t.Error("Failed to update order", err)
}
}
func ListOrderItems(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
items := []data.OrderItem{}
orderID := uint64(0)
for i := 1; i <= 3; i++ {
product, order := testProductAndOrder(tx, i)
// all items should be in the same order
if orderID == 0 {
orderID = order.ID
}
item := data.OrderItem{
Product: *product,
Quantity: uint64(i),
}
if err := tx.CreateOrderItem(orderID, &item); err != nil {
t.Fatal("Failed to create order item", err)
return
}
items = append([]data.OrderItem{item}, items...)
}
listedOrderItems, err := tx.ListOrderItems(orderID, uint64(len(items)), 0)
if err != nil {
t.Fatal("Failed to list order items", err)
return
}
if !reflect.DeepEqual(items, listedOrderItems) {
t.Errorf("Listed order items differ from created ones:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(items), testutils.JSON(listedOrderItems))
}
}
func ListProducts(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
products := []data.Product{}
for i := 1; i <= 3; i++ {
product := data.Product{
Name: fmt.Sprintf("Product #%d", i),
Price: data.Price{
Vat: 20,
Net: uint64(100 * i),
},
}
if err := tx.CreateProduct(&product); err != nil {
t.Fatal("Failed to create product", err)
return
}
products = append([]data.Product{product}, products...)
}
listedProducts, err := tx.ListProducts(uint64(len(products)), 0)
if err != nil {
t.Fatal("Failed to list products", err)
return
}
if !reflect.DeepEqual(products, listedProducts) {
t.Errorf("Listed products differ from created ones:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(products), testutils.JSON(listedProducts))
}
}
func ListOrders(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
orders := []data.Order{}
for i := 1; i <= 3; i++ {
order := data.Order{
State: data.OrderStateDraft,
Time: uint64(time.Now().UTC().Unix()),
}
if err := tx.CreateOrder(&order); err != nil {
t.Fatal("Failed to create order", err)
return
}
orders = append([]data.Order{order}, orders...)
}
listedOrders, err := tx.ListOrders(uint64(len(orders)), 0)
if err != nil {
t.Fatal("Failed to list orders", err)
return
}
if !reflect.DeepEqual(orders, listedOrders) {
t.Errorf("Listed orders differ from created ones:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(orders), testutils.JSON(listedOrders))
}
}
func LoadProduct(s storage.Adapter, t *testing.T) {
tx, err := s.Begin()
if err != nil {
t.Fatal("Failed to begin transaction", err)
return
}
defer tx.Rollback(nil)
product := &data.Product{
Name: "Product Name",
Price: data.Price{
Vat: 20,
Net: 100,
},
}
if err := tx.CreateProduct(product); err != nil {
t.Fatal("Failed to create product", err)
return
}
loadedProduct := &data.Product{
ID: product.ID,
}
if err := tx.LoadProduct(loadedProduct); err != nil {
t.Fatal("Failed to load product", err)
return
}
if !reflect.DeepEqual(product, loadedProduct) {
t.Errorf("Loaded product differs from created one:\n\ncreated: %s\n\nloaded: %s", testutils.JSON(product), testutils.JSON(loadedProduct))
}
}