ebay / flutter_glove_box

Various eBay tools for Flutter development

Flutter Glove Box

• given_when_then
• golden_toolkit
• page_object

Contains various testing tools that eBay Motors App team is using in their development on daily basis.

License Information

Copyright 2019-2023 eBay Inc.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

• Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
• Neither the name of eBay Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

flutter_glove_box's Issues

a question about app wrapping, golden_toolkit

Hello eBay,

I'm one of the contributors to the flutter platform widgets plugin,
https://github.com/stryder-dev/flutter_platform_widgets

As part of the process of improving the docs for that plugin, I am looking at how to make it work with goldens-toolkit.

I know you might know the flutter platform widgets plugin just yet as we will not become dominant until we et full testing into our plugin. However, on the dev app side, it would seem that to integrated with using flutter platform widgets I need to customize the widget wrapper so it loads the fluter platform widgets tree of PlatformProvider, and PlatformApp and have it set app target platform. That way when it targets android I pick up the right android themes and when it targets ios I pick up the right cupertino themes as flutter platform widgets rely upon platform provider to help set up themes, localizations, etc are supplied to the app widget part.

Would that be the right way to do it knowing your full code base or would there be a better way?

Thanks for making a very useful plugin!

Expose public API for device sizing even when using standard golden tests

This package contains some code that configures the size of the test canvas to replicate a "phone", "tablet", or "iphone11". It would be nice if this functionality was made public in a usable manner for golden tests that do not use a GoldenBuilder.

I'm not currently using the GoldenBuilder because for me that builder is overly specified - I want some golden tests that aren't columns or grids. But I would like to easily size the canvas to match a device. At the moment I copied that code from this package, but I'd rather just directly use that code within this package.

Provide a mechanism to better simulate safe areas in a golden test

A common class of visual UI bugs is content extending incorrectly into the safe area. The top notch is the easiest example to think of, but the bottom safe area is equally important on an iPhone X/XS, etc.

It should be easy enough to expose viewInsets into the Device configuration. However, we should consider applying an overlay onto the widget under test to highlight the safe areas.

Release v0.7.0 does not appear in GitHub releases

I see on https://github.com/eBay/flutter_glove_box/releases that the latest release is 0.6.0 , but on https://pub.dev/packages/golden_toolkit , 0.7.0 is showing.

I guess it's a matter of adding a tag to the git repo :)

Different rendering between Unix amd64 and arm64

We are used a docker image to run flutter test to avoid font rendering issues according the OS used by developers (mac, unix or windows).
Recently, we have been tried a Mac Mini M1. We generated also a new docker image based on arm64:

DockerFile for arm64:

FROM arm64v8/ubuntu:20.04

RUN apt-get update && \
    apt-get install -y bash curl file git unzip xz-utils zip libglu1-mesa

RUN git clone https://github.com/flutter/flutter.git -b "2.2.0" --depth 1

ENV PATH="$PATH:/flutter/bin"

RUN flutter config --no-analytics && \
    flutter precache

DockerFile for amd64:

FROM amd64/ubuntu:20.04

RUN apt-get update && \
    apt-get install -y bash curl file git unzip xz-utils zip libglu1-mesa

RUN git clone https://github.com/flutter/flutter.git -b "2.2.0" --depth 1

ENV PATH="$PATH:/flutter/bin"

RUN flutter config --no-analytics && \
    flutter precache

But golden tests failed on several svgs between both architectures (we are used flutter_svg).

Here an isolated diff:

Is there a solution to solve that ?

Thanks

Network images are not displayed

At the moment I found no solution to display network images. Is there any way to display these images in Golden tests

Goldens for different devices seem to influence each other.

The Goldens look as follows if I run them with respectively.

..overrideDevicesForAllScenarios(devices: [
        Device.iphone11,
        // Device.phone,
      ])
      
      
..overrideDevicesForAllScenarios(devices: [
        Device.phone,
      ])

Running them with the following setup messes up both tests.

..overrideDevicesForAllScenarios(devices: [
        Device.iphone11,
        Device.phone,
      ])

So the tests seem to influence each other :S

remove the default parameters in public methods and use them if parameter is null

We are currently having to redefine values from this library in the app because we need to override behavior and passing null is different than not having a parameter in dart.

Simple example
`
void main() {
test();
indirect();

}

void test({String value = 'hi'}) => print(value);

void indirect({String value}) => test(value: value);
`
will give
hi
null

change main to testExcutable on flutter_test_config

This just bit me on the flutter beta channel..need the change going forward past flutter 1.22

Thanks for creating a very useful plugin!

golden assertions should not require pumping with pumpWidgetBuilder

Right now, if a finder is omitted from one of our custom golden assertions, it expects that the widget was pumped via the pumpWidgetBuilder helper.

This is a bad assumption. We should eliminate the keyedsubtree and default to the entire widget tree if no finder is specified.

@mZadorskii @CaleyD

VS Code launch configuration: Property template is not allowed

Hi,
In the instruction, it says to add below launch configuration.

"configurations": [
    {
      "name": "Golden",
      "request": "launch",
      "type": "dart",
      "template": "run-test",
      "args": ["--update-goldens"]
    }

but, when I add, it say Property template is not allowed.. VS Code version 1.50.1

Is there an updated configuration?

Provide better documentation & examples of multiScreenGolden

Right now, the readme doesn't provide an overview of multiScreenGoldens. Additionally, the example test is not a great example (as it simply renders a single widget in a larger form factor). It might be worthwhile to enhance the example to actually generate a dummy screen that has more significant visual differences between form factors.

Consider segregating logical "scenario" from presentation layouts

The concept of a golden scenario is widely applicable: some render tree, some title, and possibly some arbitrary additional metadata, e.g., Map<dynamic, dynamic>.

Layout is specific to a test's use-case and team preferences, e.g., grid, column, row, surface size.

These two concepts are forced together because addScenario() is a function on GoldenBuilder, which is constructed with factories named column or grid. And the _Scenario object is private.

This creates an unnecessary limitation of usage that I'd like to break out of. I'd like to declare logical scenarios, but then gain control over how those scenarios are laid out. I considered building a package on top of golden_toolkit that would add various layouts, but that doesn't seem reasonably possible due to the above mixing of otherwise independent concepts.

I recommend separating these concepts so that the process of declaring, pumping, and rendering scenarios is consistent, but the layout of those scenarios is configurable by the end-user.

My current situation:
I've run into this limitation in multiple projects, but I'll mention my current situation which should theoretically be very easy to accomplish, but it might be impossible in the current implementation.

I'm displaying 3 button scenarios in a column. I've set the surface size to a bit larger than these 3 scenarios. I'd like for the scenarios Column to be centered in the golden UI, and I'd like the background color to fill all available space.

The GoldenBuilder build() method is currently implemented as:

///  [build] will build a list of [scenarios]  with a given layout
  Widget build() {
    return Align(
      alignment: Alignment.topLeft,
      child: Container(
        padding: const EdgeInsets.all(8),
        color: bgColor ?? const Color(0xFFEEEEEE),
        child: columns == 1 ? _column() : _grid(),
      ),
    );
  }

The alignment is hardcoded and as a result of the Align, the Container shrinks to the size of the content instead of filling the available space with the background color. So I can't center the scenarios, and I can't get the background color to fill the available space (as far as I can tell).

Bug - golden_toolkit: Special unicode characters

Hello,
I'm using the UTF-16 Unicode character '◯' ('\u{25EF}') I'm using Roboto font and it looks good on the UI. However when I perform the test, it is displayed as this:

I am also calling loadAppFonts().

Black border placed around widgets in screenshots

I have a simple Flutter widget test in which I render a BottomNavigationBar (Android) with a few items. The page content is blank (for now). The screenshot resulting from this test shows a thick black border around the BottomNavigationBar (image below); however, I do not see this border when running on an emulator or real device. I am also seeing this border appear around other widgets, such as AlertDialog, in other tests.

Is there a way to remove this border from the screenshot? My guess is that this border is somehow related to the widget tree's "focus".

Thanks ahead of time!

• Matt

Scaffold seems not supported with scenario

It seems that Scaffold and any widgets including Scaffold are not supported when attempt to create a grid or column scenario.

This generate multiple rendering exception when attempt to generate references images by flutter test --update-goldens --name=Golden

Create API for generating goldens during an animation

.sequencedGolden(filename, Iterable<int> keyFrames)
// or
.goldenSequence(filename, Iterable<int> keyFrames)

Problem running goldens tests after flutter 2.2.1 update

Hi,

After updating from 1.22.6 to 2.2.1 I get this error message when trying to run the golden tests:

/flutter_test_listener.NkmyAl/listener.dart:20:21: Error: Getter not found: 'main'.
  await Future(test.main);
                    ^^^^

I have updated my flutter_test_config.dart so the signature looks like your example app, like this:

Future<void> testExecutable(FutureOr<void> Function() testMain) async {
   return GoldenToolkit.runWithConfiguration(...

But something is still not working.
All suggestions welcome

[golden_toolkit] Font is not loaded for Debug Banner (defaults to Ahem for missing styles)

Even when await loadAppFonts() runs before all testGoldens calls, the Ahem font is still used in for most texts, e.g. the debug label, in version 0.3.1.

Support screenshots over time

This package is tailored towards multiple screenshots at one moment, like the same widget shown in 5 different ways.

A similar but different use-case is a series of screenshots over time. For example, I might have a 5 screen user journey and I'd like to capture all 5 of those steps within a single golden test so that I can easily monitor the whole flow.

It would be nice if the goldent_toolkit included a concise API to take screenshots over time and then stitch those together into a single horizontal timeline of screens.

Support for "real shadows"

Hi,

first, many thanks for this project, we started to use it this week, it's already paying off !

One of the things that we quickly noticed while adding coverage for the components library we share between applications was that shadows were rendering in a strange way, and appeared as "opaque" blocks.

After a bit of digging, I understand that, "by design", when running widget tests, shadows are rendered as solid blocks :

since the rendering of shadows is not guaranteed to be pixel-for-pixel identical from version to version (or even from run to run).

(see https://api.flutter.dev/flutter/painting/debugDisableShadows.html ).

I found this trick to temporarily "re-enable" real shadows for a given test : https://stackoverflow.com/a/64675795/474763 and indeed it does the trick.

To make it a bit easier to apply across our tests, I ended up creating a small helper function like

/// by default, Widget tests use opaque shadows to avoid golden test failures
/// we do want those on some tests to have images that look closer to reality
/// see https://stackoverflow.com/a/64675795/474763
Future<void> runWithRealShadows(Future<void> Function() callback) async {
  try {
    debugDisableShadows = false;
    await callback();
  } finally {
    debugDisableShadows = true;
  }
}

and using it in pretty much all my testGoldens tests like so :

void main() {
  testGoldens('Boxes Demo', (tester) async {
    await runWithRealShadows(() async {
      await tester.pumpWidgetBuilder(
        BoxesDemo(),
        wrapper: designSystemWrapper,
      );
      await screenMatchesGolden(
        tester,
        'boxes_demo',
      );
    });
  });
}

This is fine for now, and does the job, but I'm wondering if, since testGoldens functions are already a wrapper around testWidgets , there would be away to package this functionality as part of golden_toolkit , so that we would be able to :

• enable "real shadows" once and for all in the whole project (by setting it one in flutter_test_config.dart )
• maybe exposing it on GoldenToolkitConfiguration so it can be applied temporarily through GoldenToolkit.runWithConfiguration()

So I think that would be a nice addition to this library. If you think so too, I'd be happy to try and come up with a PR with an initial proposal of what it could look like.

Different font rendering between Unix and macOS

I tried the golden toolkit and it works great on my machine. I'm working on a MacBook with macOS 10.15.6.

Our CI is running on a unix machine and the golden tests always fail. On the first look the screens look the same. If you look carefully, you can see little differences around texts. Obviously the anti aliasing works diffently.

If my colleague creates the goldens on his unix machine, they match on the CI.

I already tried to turn off the font smoothing in the macOS system settings. Then the rendered text is looking diffently than with smoothing. But also still differently from unix.

Is there anything we can do about? Or can you fix that in the toolkit?

Example Application

Create an example application that showcases the usage of all flutter_glove_box packages.

Font not load when apply TextStyle on TabBar labels

Hello,

Font of text label in tabBar widget are not loaded when I attempt to golden test a widget with a style applied on tabBar labels.

Here the widget I attempt to test :

class MyHomePage extends StatelessWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;

  @override
  Widget build(BuildContext context) {
    return DefaultTabController(
      length: 3,
      child: Scaffold(
        appBar: AppBar(
          title: Text(title),
          bottom: TabBar(
            labelStyle: TextStyle(fontSize: 20),
            tabs: [
              Text('List'.toUpperCase()),
              Text('News'.toUpperCase()),
              Text('Previews'.toUpperCase()),
            ],
          ),
        ),
        body: TabBarView(
          children: [
            GameList(
              key: Key('gameList'),
              games: GameRepository().games,
            ),
            Text('here news view'),
            Text('here previews view'),
          ],
        ),
      ),
    );
  }
}

When I add a value to the labelStyle parameter, the font of the tab labels are not loaded exactly as the load font issue #31 .
And when any label style is specified, everything works fine.

In addition, adding style in the Text widget into the TabBar does not cause any issue. Seems the labelStyle parameter cause this issue. The others TabBar parameters work fine.

Support asynchronous Scenarios

I'm trying to assemble a golden sheet of button states: normal, pressed, and disabled.

For a pressed button state, I need to orchestrate a tap, but there doesn't appear to be any place within a standard Scenario to do this. A Widget is expected. There should probably be an option for a function that returns Future<Widget> or something like that.

It looks like a DeviceScenario supports onCreate, which might allow for this, but onCreate is not offered for regular scenarios.

testGoldens shouldn't be a future

testGoldens has a Future signature. It is not needed and should be just a void function.

golden_toolkit: Broken text on RichText golden file

Hello!

We are using golden_toolkit (0.9.0) on Flutter 2.2.0 and we are having issues with the RichText widget. Here's a very simple golden:

testGoldens('Broken', (tester) async {
  const text = Text('Hello world');
  final richText = RichText(
    text: const TextSpan(
      text: 'Hello',
      children: [
        TextSpan(
          text: 'world!',
        ),
      ],
    ),
  );

  final builder = GoldenBuilder.column()
    ..addScenario('Text', text)
    ..addScenario('Rich text', richText);

  await tester.pumpWidgetBuilder(
    builder.build(),
    surfaceSize: const Size.square(180),
  );

  await screenMatchesGolden(tester, 'broken');
});

This is the result we get:

As you can see, the text inside Text is correctly rendered while RichText only has white squares. Considering that Flutter's default behavior on golden tests is showing white squares instead of the actual chars, we suspect that (probably) there's an issue in golden_toolkit with font files.

We have only found this issue with the RichText widget and nowhere else. Is this a known issue? Are we doing something wrong or there might be some digging into the package to figure out where the issue is?

How to work with GoogleFonts

I know that font support is limited. Is there any way to configure golden tests to work with google_fonts? At the moment my test outright fails due to Error: google_fonts was unable to load font...

This is primarily an issue with google_fonts, but I was wondering if your team had any remedies for this?

Fonts not loading when new buttons (ElevatedButton, TextButton, OutlinedButton) are themed with TextStyle

When the new buttons (ElevatedButton, TextButton, OutlinedButton) are styled the recommended way using ThemeData, and TextStyle is added as a property, 'Roboto' is no longer loaded as the default font during golden tests. Instead, 'Ahem' is now displayed as a fallback. Steps to reproduce:

1. git clone https://github.com/eBay/flutter_glove_box.git
2. Add an ElevatedButton to the column in packages/golden_toolkit/example/lib/src/flutter_demo_page.dart like so:

children: <Widget>[
  ElevatedButton(onPressed: () {}, child: const Text('Test')),
  const Text(
    'You have pushed the button this many times:',
),

3. Save and run flutter test --update-goldens to enjoy the ElevatedButton being rendered with text.
4. Now let's add theme data to the button (here, we want to increase the default size of the button text):

  visualDensity: VisualDensity.adaptivePlatformDensity,
  elevatedButtonTheme: ElevatedButtonThemeData(
    style: ElevatedButton.styleFrom(
      textStyle: const TextStyle(fontSize: 20),
    ),
  ),
),
home: const _MyHomePage(title: 'Flutter Demo Home Page'),

5. Save and run flutter test --update-goldens again to immediately drown in sadness over button text not being rendered.

If the code is compiled and executed normally, e.g. in the simulator, the button text is shown normally (with the expected larger font size).

As far as I can tell, there are three workarounds:

1. Specify a fontFamily. If fontFamily: 'Roboto' is used, Roboto will be loaded during golden testing. However, the switch between Android and iOS fonts would no longer happen automatically. You therefore typically want to avoid hardcoding your font.
2. Avoid specifying the textStyle parameter in ThemeData but use it in the Text widget whenever needed. That, of course, goes against the idea of using themes in general, but in fact is what we now do in our production code to correctly render goldens for our reviewers and not hardcode 'Roboto'.
3. Specify fontFamily: DefaultTextStyle.of(context).style.fontFamily. This works in the example app but somehow failed in our production code, maybe because we have the text styles deeply nested in providers for each Android and iOS. It also requires context to be passed around.

You see, having loadAppFonts() loading the correct default font with the ability to specify TextStyle would be highly practical for us. 😋

Improve general documentation

Provide some general overview that touches on the following:

• explain rationale of testGoldens() test function (reference ability to run only golden tests when regenerating from the command-line)

• include vscode snippet for regenerating Goldens from IDE

• provide a brief note on when it is appropriate to use a golden test vs. a traditional widget test. highlight test speed & overhead

• add note about suppressing failure assets in gitignore

Certain fonts will not load in Golden Tests

If you use a custom font across multiple packages, and the fontFamily's name is contained in the _overridableFonts list, it will not be treated as an asset font and will not load in Goldens.

I created a small project that demonstrates the issue: https://github.com/NickalasB/golden_font_issue

Steps To Reproduce:

• Clone the repo and cd into the ui package and run flutter packages get

• cd into the app package and run flutter packages get then flutter test --update-goldens

Actual Behavior
The font_family_fail.png Golden fails to properly load the RobotoMono font defined inside ui/pubspec.yaml

Expected Behavior
The font_family_fail.png should properly display the Golden with RobotoMono font

Additional Information
As discussed in this issue there is a logic issue when a custom font is used and the name is contained with the _overridableFonts.

If you change the name of the family inside ui/pubspec.yaml, then delete the app/build directory, then regenerate Goldens, you will see the issue is fixed

Submitting a PR shortly to address

Add example to page_object on pub.dev

Follow the documentation here: https://dart.dev/tools/pub/package-layout#examples

This will show an example on pub.dev

Investigate auto-sizing the surfaceSize before capturing the golden.

Right now, it is possible to capture golden screenshots that exceed the dimensions of the target device size. This is valuable for asserting that all content looks correct, without the need for scrolling. However, doing this often requires manual overriding of the golden size. As widgets change, this override requires micro-management. Additionally, if the overridden size is much larger than the content, then the captured golden is large and full of dead space.

We should investigate if we can compute the size needed and shrink the surface size accordingly.

I suspect this will require additional pumps and likely add latency to the golden assertion. Assuming this is the case, we should consider this an opt-in feature and still allow for fine-grained sizing.

restore device bindings upon completion of multiScreenGolden

the WidgetTester bindings do not get reset in between tests, which means that the multiScreenGolden assertions can bleed through to the next test. We should revert back to the previous settings after looping through the devices.

Device Pixel Ratio should apply to window and viewport size

Setting devicePixelRatio does not change the viewport size. So, I'm proposing that the property be applied to the viewport size.

For a Device configuration such as:

static const Device iPhone12ProMax = Device(
name: 'iPhone 12 Pro Max', size: Size(1284, 2778), devicePixelRatio: 3);

The actual viewport size is 428 x 926. When this configuration is used however, the viewport is the pixel size which makes the UI too small.

There is also an internal Flutter issues that the team is aware of where Flutter widgets use the window properties instead of the wrapping MaterialApp, hence setting the properties via MediaQueryWrapper does not work. Hence the solution is to divide the screen size by the pixel ratio and use that as the correct viewport.

Add support for platform-specific goldens

Goldens generated on Mac will differ from those on linux. Currently, we only support a single set of golden images which means either that CI will fail 100% of the time, or local testing will fail 100% of the time.

We should investigate a convention of adding .linux or .macos into he file names so that we can disambiguate.

Additionally, we need to provide a way to regenerate linux based goldens.

We should also consider a check to make sure that if a golden changes for one platform, that the other platform's golden is updated as well.

pub dev documentation should suggest installing as a `dev_dependency`

When going to

https://pub.dev/packages/golden_toolkit/install

It suggests to install the package by adding it as a dependency :

dependencies:
  golden_toolkit: ^0.7.0

It should probably recommend to install it as a dev_dependency . Not sure how this is done, but for instance build_runner does appear as a dev_dependency :

https://pub.dev/packages/build_runner/install

"Basic golden test for empty container Animation test with CustomPump Golden" is failing for me since day 1

The " Basic golden test for empty container Animation test with CustomPump Golden" test fails with a diff of 3.06% for me since the first commit.

Could anyone confirm that?

page object example has errors

In the examples, page object examples has errors:

final titleFinder = find.descendant(
       of: find.descendant(
        of: find.byType(MyApp),
          matching: find.byType(MyHomePage),
         ),
        matching: find.byKey(MyHomePage.titleKey),
        );
        final messageFinder = find.descendant(
         of: find.descendant(
           of: find.byType(MyApp),
          matching: find.byType(MyHomePage),
       ),
        matching: find.byKey(MyHomePage.messageKey),
         );

Never returns any mathes while this in fact does;

final titleFinder = find.text(myAppTitle);
        final messageFinder = find.text(myHomePageMessage);

as since we do not test the hierarchy there is no direct need to do a descendent test as there is only one title in the ap ponly one homepage message

Provide a way to customize golden file name

Currently the golden file name is set to:

final fileName = 'goldens/$goldenFileName.png';

Which forces the golden files to be in the golden directory which is not optimal for some setups.

It would be nice if you could provide sth. like a fileNameBuilder/Factory which is simply a function that takes in a goldenFileName and outputs the actual golden file name. To make the change backwards compatible it should default to:

String defaultFileNameFactory(String goldenFileName) {
  return 'goldens/$goldenFileName.png';
}

This would enable other testing setups to put the files in another directory :D

Move sample tests into /example

Missing /example is causing PANA score to be low.

• move sample weather widget code into example
• move the main example tests into example
• ensure code coverage is still maintained in golden_toolkit
• Update image/file references in docs to point to new location

Share analysis_options.yaml

As we move to supporting multiple packages we should move the shared analysis_options file to the root of the repo so that we avoid duplicating it in each package.

Golden Test Dialogs

I'm trying to use Golden Toolkit to unit test the a dialog.
I am testing it by pressing a button and making the dialog show up.
Using multiple devices for every scenario.
But the dialog shows in the middle of the golden, darkening the whole image, instead showing inside each of the tests inside the golden, and darkening just each test.
I am punting the function that invoke the dialog inside a button, wrapped inside a Scaffold, wrapped inside a Material App.
Can you help me?

allow all injecting of pumping behavior for multiscreen golden

Currently multiscreen golden has 2 pumps inside for when the device size changes. This should be configurable.

This is needed in cases where several run loop cycles are needed whenever the screen is refreshed.

Add example to pub.dev for given_when_then

Follow the documentation here: https://dart.dev/tools/pub/package-layout#examples

This will show an example on pub.dev

Missing null safety support / Library is legacy

Trying to use golden_toolkit with a null safe library will generate the following warning:

The library 'package:golden_toolkit/golden_toolkit.dart' is legacy, and should not be imported into a null safe library. Try migrating the imported library.

This is because there is no -nullsafety version for golden_toolkit yet.

Quoting from the email that has been sent to applicable package authors:

You can find information on the migration at dart.dev/null-safety, including links to a migration guide and frequently asked questions.

Adjust the default surfaceSize to be more indicative of a normal device

WidgetTester defaults to a 800x600 surface size (at 3.0 DPI). We could consider defaulting our golden tests to a more reasonable default (perhaps the dimensions of an iPhone X or Pixel 3). Additionally, consider dropping the DPI to 1.0 in order to speed up the tests.

loadAppFonts() will fail if package does not contain any image assets.

For a currently unknown reason, if a package does not contain any images, then the FontManifest.json is not generated, even if it depends on other packages with fonts/images

We need to investigate if this is a bug in Flutter or working as intended. If working as intended, we may need to come up with an alternative solution for loading fonts.

screenMatchesGolden sometimes creates failure folders even when the test succeeds

This seems to be caused by await _primeImages(fileName, actualFinder);.
Sometimes things are not completely settled here and a failure folder is created.
The test ist still successful but failure artifacts are published in the CI system.

I can work around it by using pumpAndSettle in the deviceSetup but it seems weird.

Why do the golden images needed to be primed at all? Commenting this out doesn't seem to have an effect on duration or test results.

Thanks for the library!

Support for Flutter Web

Currently this package is not compatible with web platform. Please consider adding support for flutter web. Thanks.