NAME

    Jasmine::Spy

VERSION

    version 0.9

SYNOPSIS

        use Test::Spec;
        use Jasmine::Spy qw(spyOn stopSpying expectSpy);
    
        describe "FooClass" => sub {
            before each => sub {
                spyOn("BarClass", "bazMethod")->andReturn("Bop");
            };
            it "calls BarClass" => sub {
                FooClass->doTheThing();
                expectSpy("BarClass", "bazMethod")->toHaveBeenCalled();
            };
            after each => sub {
                stopSpying("BarClass");
            };
        };

Methods

    Nothing is exported by default, but they cann all be pulled in with the
    :all tag

 Base Class Methods

    spyOn($invocant, $method)

      This is the setup method to begin spying. $invocant may be either an
      object instance or the name of a class. Spying on a Class will
      automatically spy on all instances of the class, even those created
      before setting up the spy. Spyng on an instance only effects that
      instance, not the class or other instances of that class.

      A "spy" object is returned from this call which will allow
      introspection and testing of calls. However there is no need to catch
      this, as other convience methods provide a better way of performing
      the same introspection later.

    stopSpying($invocant)

      Use this call to stop spying and restore original functionality to
      the object or class.

    expectSpy($invocant, $method)

      Use this to retrieve the "spy" object created by spyOn. It also sets
      the spy object to introspect of the provided $method. There is only
      one spy object created for each distinct $invocant beign spied on,
      even if multiple methods are being watched. This is why expectSpy is
      the recomended way to start introspection on a spied method.

    getCalls($invocant, $method)

      This will fetch an array of array's containing the arguments passed
      each time the $method was called. This is a tied array ref which also
      provides convience methods first and mostRecent.

 Spy object methods

    toHaveBeenCalled

      Test that the spied method has been called atleast once.

    notToHaveBeenCalled

      Test that the spied method was never called.

    toHaveBeenCalledWith($matchers)

      Expects that the spied method has been called with arguments matching
      $matchers atleast once. This is done with deep comparison via
      Test::Deep.

    notToHaveBeenCalledWith($matchers)

      Inverse of toHaveBeenCalledWith.

    andReturn($value)

      Sets the spied method to return the supplied value. Usually this
      would be called directly on the return from spyOn.

      For example:

          spyOn($foo, 'bar')->andReturn('baz')

    andCallThrough

      Sets the spied method to call through to the original method,
      recording arguments passed along the way.

    andCallFake(sub {})

      Sets the spied method to invoke the supplied code reference in place
      of the original method. It does also record the arguments along the
      way.

TODO

    Convience Method for toHaveBeenCalledTimes

    Convience Method for andThrow

    Method to reset the list of calls

    Method for andReturnValues (like the most recent release of jasmine )

See also

    Test::Spec, Test::Deep