HitchDev
Draft content
Initializing search
HitchDev
About
Consulting
Contact me
Commandlib
Commandlib
Changelog
Using
Using
Alpha
Alpha
Add directory to PATH (with_path)
Capture output (.output())
Easily invoke commands from one directory (CommandPath)
Change your command's environment variables (with_env)
Run command and don't raise exception on nonzero exit code (ignore_errors())
Piping data in from string or file (.piped)
Piping data out to string or file (.piped)
Run commmands interactively using icommandlib or pexpect
Easily invoke commands from the current virtualenv (python_bin)
Faketime
Faketime
Hitchdb
Hitchdb
Changelog
Approach
Approach
Using
Using
Postgres Types
Quickstart
Hitchpage
Hitchpage
Changelog
Approach
Approach
Page Config Model
Using
Using
Iframe
Quickstart
Reload
Hitchrunpy
Hitchrunpy
Changelog
Using
Using
Alpha
Alpha
Cprofile
Environment vars
Exceptions
Include files
Interact with running code
Setup code
Syntax errors
Timeout
Variables
Hitchstory
Hitchstory
Changelog
Approach
Approach
Is HitchStory a BDD tool? How do I do BDD with hitchstory?
Complementary tools
Domain Appropriate Scenario Language (DASL)
Executable specifications
Flaky Tests
The Hermetic End to End Testing Pattern
ANTIPATTERN - Analysts writing stories for the developer
Separation of Test Concerns
Snapshot Test Driven Development (STDD)
Test Artefact Environment Isolation
Test concern leakage
Tests as an investment
What is the difference betweeen a test and a story?
The importance of test realism
Testing non-deterministic code
Specification Documentation Test Triality
Using
Using
Behavior
Behavior
Abort a story with ctrl-C
Upgrade breaking changes between v0.14 and v0.15
Handling failing tests
Running a single named story successfully
Documentation
Documentation
Generate documentation with extra variables and functions
Generate documentation from story
Engine
Engine
Hiding stacktraces for expected exceptions
Given preconditions
Gradual typing of story steps
Match two JSON snippets
Match two strings and show diff on failure
Extra story metadata - e.g. adding JIRA ticket numbers to stories
Story with parameters
Story that rewrites given preconditions
Story that rewrites itself
Story that rewrites the sub key of an argument
Raising a Failure exception to conceal the stacktrace
Arguments to steps
Strong typing
Inheritance
Inheritance
Inherit one story from another simply
Story inheritance - given mapping preconditions overridden
Story inheritance - override given scalar preconditions
Story inheritance - parameters
Story inheritance - steps
Variations
Pytest
Pytest
Self rewriting tests with pytest and hitchstory
Runner
Runner
Continue on failure when playing multiple stories
Flaky story detection
Play multiple stories in sequence
Run one story in collection
Shortcut lookup for story names
Setup
Setup
Creating a basic command line test runner
Why
Why
Declarative User Stories
Why does hitchstory mandate the use of given but not when and then?
Why is inheritance a feature of hitchstory stories?
Why does hitchstory not have an opinion on what counts as interesting to "the business"?
What does the license mean for me?
Why does hitchstory not have a command line interface?
Principles
Why does HitchStory have no CLI runner - only a pure python API?
Why Rewritable Test Driven Development (RTDD)?
Why does HitchStory use StrictYAML?
Why not
Why not
Why use Hitchstory instead of Behave, Lettuce or Cucumber (Gherkin)?
Why not use the Robot Framework?
Why use hitchstory instead of a unit testing framework?
Icommandlib
Icommandlib
Changelog
Using
Using
Custom Screen Condition
Kill
Process properties
Screenshot
Screensize
Send keys
Wait until successful exit
Orji
Orji
Changelog
Using
Using
Demonstration of all template features
Deliberately trigger a template failure
Insert file
Example of Generated LaTeX A4 CV
Example of Generated LaTeX A4 Letter
Convert chunks of orgmode text into markdown
Use a python module with template variables and methods
Templated with more than one note
Run
Strictyaml
Strictyaml
Changelog
What YAML features does StrictYAML remove?
What is YAML?
When should I use a validator and when should I not?
Using
Using
Alpha
Alpha
Compound
Compound
Fixed length sequences (FixedSeq)
Mappings combining defined and undefined keys (MapCombined)
Mappings with arbitrary key names (MapPattern)
Mapping with defined keys and a custom key validator (Map)
Using a YAML object of a parsed mapping
Mappings with defined keys (Map)
Optional keys with defaults (Map/Optional)
Validating optional keys in mappings (Map)
Sequences of unique items (UniqueSeq)
Sequence/list validator (Seq)
Updating document with a schema
Howto
Howto
Build a YAML document from scratch in code
Either/or schema validation of different, equally valid different kinds of YAML
Labeling exceptions
Merge YAML documents
Revalidate an already validated document
Reading in YAML, editing it and writing it back out
Get line numbers of YAML elements
Parsing YAML without a schema
Restrictions
Restrictions
Disallowed YAML
Duplicate keys
Dirty load
Scalar
Scalar
Boolean (Bool)
Parsing comma separated items (CommaSeparated)
Datetimes (Datetime)
Decimal numbers (Decimal)
Email and URL validators
Empty key validation
Enumerated scalars (Enum)
Floating point numbers (Float)
Hexadecimal Integers (HexInt)
Integers (Int)
Validating strings with regexes (Regex)
Parsing strings (Str)
Why
Why
What is wrong with duplicate keys?
What is wrong with explicit tags?
What is wrong with flow-style YAML?
The Norway Problem - why StrictYAML refuses to do implicit typing and so should you
What is wrong with node anchors and references?
Why does StrictYAML not parse direct representations of Python objects?
Why does StrictYAML only parse from strings and not files?
Why is parsing speed not a high priority for StrictYAML?
What is syntax typing?
Why does StrictYAML make you define a schema in Python - a Turing-complete language?
Why not
Why not
Why avoid using environment variables as configuration?
Why not use HJSON?
Why not HOCON?
Why not use INI files?
Why not use JSON Schema for validation?
Why not JSON for simple configuration files?
Why not JSON5?
Why not use the YAML 1.2 standard? - we don't need a new standard!
Why not use kwalify with standard YAML to validate my YAML?
Why not use Python's schema library (or similar) for validation?
Why not use SDLang?
What is wrong with TOML?
Why shouldn't I just use Python code for configuration?
Why not use XML for configuration or DSLs?
Draft content
This section contains draft content.