def test_time_classes(inputs, time_ref): data = write_read_buffer({"root": inputs}) assert np.all(data["root"] == inputs) if isinstance(inputs, pd.Index) and not inputs.is_monotonic: # this is not valid for the time class, hence cancel here return t1 = Time(inputs, time_ref) t2 = write_read_buffer({"root": t1})["root"] assert t1.equals(t2)
def test_graph_exceptions(self): self.graph.remove_edge("A", "C") # two trees in graph with pytest.raises(ValueError): write_read_buffer(dict(graph=self.graph)) self.graph.remove_nodes_from(("C", "D")) # cleanup self.graph.add_edge("H", "A") # create loop with pytest.raises(ValueError): write_read_buffer(dict(graph=self.graph)) with pytest.raises(KeyError): self.graph_uuid._wx_keep_uuid_name = False g = self.graph_uuid self._assert_roundtrip(g)
def test_dataset_children(): da = xr.DataArray(np.arange(10), name="arr1", attrs={"name": "sample data"}) ds = da.to_dataset() ds2 = write_read_buffer({"ds": ds})["ds"] assert ds2.identical(ds)
def test_asdf_groove(groove: IsoBaseGroove, expected_dtype): """Test ASDF functionality for all grooves. Parameters ---------- groove: Groove instance to be tested. expected_dtype: Expected type of the groove to be tested. """ k = "groove" tree = {k: groove} data = write_read_buffer(tree) assert isinstance( data[k], expected_dtype ), f"Did not match expected type {expected_dtype} on item {data[k]}" # test content equality using dataclass built-in functions assert (groove == data[k] ), f"Could not correctly reconstruct groove of type {type(groove)}" # test to_profile assert isinstance( groove.to_profile(), Profile), f"Error calling plot function of {type(groove)} " # call plot function fig, ax = plt.subplots() groove.plot(ax=ax) plt.close(fig)
def test_dataarray(): da = xr.DataArray(np.random.randn(2, 3), dims=("x", "y"), coords={"x": [10, 20]}) da.attrs["long_name"] = "random velocity" # add metadata to coordinate da.x.attrs["units"] = "x units" da2 = write_read_buffer({"da": da})["da"] assert da2.identical(da)
def test_measurement_chain(copy_arrays, lazy_load, measurement_chain): """Test the asdf serialization of the measurement chain.""" tree = {"m_chain": measurement_chain} data = write_read_buffer(tree, open_kwargs={ "copy_arrays": copy_arrays, "lazy_load": lazy_load }) mc_file = data["m_chain"] assert measurement_chain == mc_file
def _assert_roundtrip(g): data = write_read_buffer(dict(graph=g)) g2 = data["graph"] for node in g: assert g.nodes[node] == g2.nodes[node] for edge in g.edges: assert g.edges[edge] == g2.edges[edge] assert set(g.nodes) == set(g2.nodes) assert set(g.edges) == set(g2.edges)
def test_meta_attr(): e = Error(3.0) ts = pd.DatetimeIndex(["2020", "2021"]) setattr(ts, META_ATTR, {"name": "reference years"}) setattr(e, META_ATTR, {"ts": ts}) setattr(e, USER_ATTR, {"description": "user info"}) tree = {"Error": e} data = write_read_buffer(tree) e2 = data["Error"] assert e2 == e assert compare_nested(getattr(e2, META_ATTR), getattr(e, META_ATTR)) assert compare_nested(getattr(e2, USER_ATTR), getattr(e, USER_ATTR)) assert compare_nested(getattr(getattr(e2, META_ATTR)["ts"], META_ATTR), getattr(ts, META_ATTR))
def test_shape_validator(test_input): result = write_read_buffer({"root": test_input}, )["root"] assert compare_nested(test_input.__dict__, result.__dict__) assert compare_nested(result.__dict__, test_input.__dict__)
def test_gmaw_process(inputs): data = write_read_buffer({"root": inputs}) assert data["root"] == inputs