From 38c9e739bb68b1dbbb0e8ab8c1b6c2bfad48b768 Mon Sep 17 00:00:00 2001 From: angelicalin Date: Fri, 9 Mar 2018 14:11:27 -0600 Subject: [PATCH] homework done --- lib/desugaring.rb | 32 ++++++++++++++++------ lib/retail_transaction.rb | 5 ++++ test/retail_transaction_test.rb | 47 +++++++++++++++++++++++++++++++++ 3 files changed, 76 insertions(+), 8 deletions(-) diff --git a/lib/desugaring.rb b/lib/desugaring.rb index 8d52908..bff8461 100644 --- a/lib/desugaring.rb +++ b/lib/desugaring.rb @@ -21,7 +21,9 @@ def all_the_sugar(recipients, event, message) # Copy the contents of the previous method here and remove this sugar. # def desugared_poetry(recipients, event, message) - implement_me! + mail(message, + to: recipients.map(&:email), + subject: "You’re invited to #{event.title} on #{event.date}") end # Ruby allows you to pass arguments identified by name instead of just by position. They are really just @@ -36,7 +38,9 @@ def desugared_poetry(recipients, event, message) # Copy the contents of the previous method here and remove this sugar. # def desugared_named_args(recipients, event, message) - implement_me! + mail(message, + {to: recipients.map(&:email), + subject: "You’re invited to #{event.title} on #{event.date}"}) end # Ruby’s general syntax for hashes is `{key => value, key => value, ...}`. Because it is so common to use @@ -51,7 +55,9 @@ def desugared_named_args(recipients, event, message) # Copy the contents of the previous method here and remove this sugar. # def desugared_symbol_keys(recipients, event, message) - implement_me! + mail(message, + {:to=>recipients.map(&:email), + :subject=> "You’re invited to #{event.title} on #{event.date}"}) end # You may be wondering how `map(&:email)` works. When you precede the last argument of a method call with @@ -70,7 +76,9 @@ def desugared_symbol_keys(recipients, event, message) # Copy the contents of the previous method here and remove this sugar. # def desugared_attr_proc(recipients, event, message) - implement_me! + mail(message, + {:to=>recipients.map{|x| x.email}, + :subject=> "You’re invited to #{event.title} on #{event.date}"}) end # You may recall from the Ruby koans that when you put `#{something}` in a `"`-delimited string, Ruby will @@ -88,7 +96,9 @@ def desugared_attr_proc(recipients, event, message) # Copy the contents of the previous method here and remove this sugar. # def desugared_interpolation(recipients, event, message) - implement_me! + mail(message, + {:to=>recipients.map{|x| x.email}, + :subject=> "You’re invited to "+event.title+" on " + event.date}) end # Ruby tracks local variables lexically at compile time. Wherever you say `x = y`, the compiler assumes that @@ -110,7 +120,9 @@ def desugared_interpolation(recipients, event, message) # (Think: which names are local variables, and which are not?) # def desugared_implicit_self(recipients, event, message) - implement_me! + self.mail(message, + {:to=>recipients.map{|x| x.email}, + :subject=> "You’re invited to "+event.title+" on " + event.date}) end # In Ruby, unlike Python, there are no properties distinct from method calls. When you say `x.y`, you are @@ -131,7 +143,9 @@ def desugared_implicit_self(recipients, event, message) # but structurally quite similar! # def desugared_implicit_parens(recipients, event, message) - implement_me! + self.mail(message, + {:to=>recipients.map{|x| x.email()}, + :subject=> "You’re invited to "+event.title()+" on " + event.date()}) end # In Ruby, every value is an object and every action is a method call. That includes operators. A binary @@ -153,7 +167,9 @@ def desugared_implicit_parens(recipients, event, message) # get added before the things on the right. (a + b + c) means ((a + b) + c), NOT (a + (b + c)). # def desugared_operators(recipients, event, message) - implement_me! + self.mail(message, + {:to=>recipients.map{|x| x.email()}, + :subject=> (("You’re invited to ".+(event.title())).+(" on ")).+(event.date())}) end # Compare that to the version at the top. diff --git a/lib/retail_transaction.rb b/lib/retail_transaction.rb index 1bfa0e3..15d7d78 100644 --- a/lib/retail_transaction.rb +++ b/lib/retail_transaction.rb @@ -39,6 +39,7 @@ def paid? state :processing_payment state :payment_declined state :settled + state :refunded event :check_out do transitions from: :ringing_up, to: :collecting_payment, @@ -61,5 +62,9 @@ def paid? event :payment_declined do transitions from: :processing_payment, to: :payment_declined end + + event :refund do + transitions from: :settled, to: :refunded + end end end diff --git a/test/retail_transaction_test.rb b/test/retail_transaction_test.rb index 823cbfe..d514172 100644 --- a/test/retail_transaction_test.rb +++ b/test/retail_transaction_test.rb @@ -97,12 +97,35 @@ assert_equal false, tx.payment_declined? end + + it "can handle payment declined" do tx.payment_declined! assert_equal false, tx.processing_payment? assert_equal false, tx.settled? assert_equal true, tx.payment_declined? end + + it "declined payment cannot be refunded" do + assert_invalid_transition{tx.refund!} + end + + + end + + describe "with settled payment" do + before(:each) do + tx.add_item("bobcat") + tx.check_out! + tx.payment_info = "15 cents and a nail" + tx.process_payment! + tx.payment_authorized! + end + + it "settled payment can be refunded" do + tx.refund! + assert_equal true, tx.refunded? + end end describe "with declined payment" do @@ -114,6 +137,10 @@ tx.payment_declined! end + it "cannot refund declined payments" do + assert_invalid_transition{tx.refund!} + end + it "cannot add more items" do assert_raises do tx.add_item("half a slice of bologna") @@ -132,6 +159,7 @@ assert_equal true, tx.processing_payment? end + it "can change payment info" do tx.payment_info = "15 cents and a nail and the shell of a great great great grandfather snail" tx.process_payment! @@ -153,4 +181,23 @@ assert_invalid_transition { tx.reopen! } end end + + describe "that is refunded" do + before(:each) do + tx.add_item("bobcat") + tx.check_out! + tx.payment_info = "15 cents and a nail" + tx.process_payment! + tx.payment_authorized! + tx.refund! + end + + it "cannot be refunded a second time" do + assert_invalid_transition {tx.refund!} + end + + it "cannot be reopened" do + assert_invalid_transition {tx.reopen!} + end + end end