Overview

Expycted is yet another expect pattern implementation.

It is not dependent on any testing framework and can plug into any as it is just an abstraction over assert.

Examples:

from expycted import expect

expect(True).to_not.be_false()                                  # This will succeed

expect([]).to.be_empty()                                        # This will succeed

expect([1,2,3]).to.contain(3)                                   # This will succeed

expect(10).to.equal("10")                                       # This will raise AssertionError

expect(10).to.be("10")                                          # This will succeed

expect.function(int).to_raise(ValueError).when_called_with('a') # This will also succeed

Installation

Expycted can be installed from PyPi by using:

pip install expycted

Alternatively, you can clone the repository and build your own distribution using poetry.

git clone https://github.com/petereon/expycted.git
poetry build

Then you can install it using:

pip install ./dist/expycted--py3-none-any.whl

Matchers

Matchers are used to ensure some conditions are met.

Value Matchers

Value matchers can be used in two equivalent ways demonstrated below:

expect.value(10).to.be_greater_than(1)
expect(10).to.be_greater_than(1)

Currently available matchers are:

• Eqality and similarity
  • equal(self, value): equivalent to "==". With alias be_equal_to
  • be(self, value): will check if string representation of values is same or if two objects have the same attributes or are equal
• Numeric
  • be_greater_than(self, value): equivalent to ">". With alias be_greater
  • be_lesser_than(self, value): equivalent to "<". With alias be_lesser , be_less, be_less_than
  • be_greater_or_equal_to(self, value): equivalent to ">=". With aliases be_greater_or_equal, be_greater_than_or_equal_to
  • be_lesser_or_equal_to(self, value): equivalent to "<=". With aliases be_lesser_or_equal, be_less_or_equal, be_less_than_or_equal_to, be_lesser_than_or_equal_to
  • be_numeric(self): checks if self.value is a number or string covertible to a number. With alias be_a_number
• Containment and Emptiness
  • contain(self, value): equivalent to "in". With aliases have, include
  • be_contained_in(self, value): equivalent to "in". Qith aliases be_in, be_included_in
  • be_empty(self): checks if self.value is iterable and False
• Truthiness
  • be_true(self): checks if self.value is True
  • be_false(self): checks if self.value is False
  • be_truthy(self): checks if self.value behaves true in if statement. With aliases be_truey, be_trueish
  • be_falsey(self): checks if self.value behaves false in if statement. With aliases be_falsy, be_falsish
• Typing
  • be_of_type(self, value): checks if self.value is of specified type. With aliases be_type, have_type
  • inherit(self, value): checks if self.value inherits/is a specified type. be_subclass_of, have_parent

Function Matchers

Function matchers can be called as such:

expect.function(string.replace).to_return('strength').when_called_with('ing', 'ength')

Currently available matchers are:

• to_return(self, value=None, type_of_value=None) - checks if function returns a specified value, or type, or both.
• to_raise(self, exception_type) - checks if function raises a specified exception.

In each case we have to specify arguments with which function is called in .when_called_with method. Method has aliases when_called_with_args, when_called_with_arguments

Filesystem Matchers

Filesystem matchers can be called as such:

expect.folder('/some/folder').to.contain('subfolder')

Currently available matchers are:

• contain(self, name, type: Union[File, Folder, None, str] = None) - checks if folder contains a specified file or folder. If type is specified, it will check if file is file or folder is folder.
• contain_file(self, name) - checks if folder contains a specified file.
• contain_folder(self, name) - checks if folder contains a specified folder.
• exist(self) - checks if folder exists.
• be_empty(self) - checks if folder is empty.

They can be used with both expect.folder('/some/folder').to and expect.folder('/some/folder').to_not to check both positive and negative expectations.